设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?, S9 Z! t) X5 O( t
    " F( t2 `, ~. F. ~
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。# F4 I+ m: I8 v5 C# P
    . T5 v7 @- G, R9 _
    速度优化问题真的很有意思啊。# H5 h& z  \+ l4 V' q( }+ X" P3 d* Y

    / I  n, A6 [, O( q欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    5 天前
  • 签到天数: 1934 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?7 J' k) Y" T  x1 d6 \$ }; u3 Q
    把代码贴上来看看?2 `+ ]* b+ M. R5 L* q! J$ U

    9 G3 w3 J+ s9 Y: r) f3 j1 x) `难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2025-6-14 10:13
  • 签到天数: 124 天

    [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 编辑
    9 H5 {: ]7 P9 g/ e- s" t) B* Z
    数值分析 发表于 2022-9-24 23:04
    ( Q3 v7 p) x$ K' A# ?拉下来?拉多少?
    : c4 i( |" ]2 l: r) `3 U- i/ U- O2 x把代码贴上来看看?

    3 v1 S2 z: H" N: K! x: G
      q2 s# ]2 U6 q# a4 Evoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)# o8 o- |4 H. v5 k2 r  m( o. ]
    {. Y/ G: _- c& q9 r
            comp temp, xtimesy;  z; a; O% C. {3 O8 b) g, Z  G4 j
            xtimesy.re = 0;2 R0 Y' R0 S! Y3 z
            xtimesy.im = 0;# ]$ n% G( ]$ i4 p
            int j0 = lenB - 1;+ i5 N) X0 L* ?1 a- h4 [0 c
            int    i, j, i1, reali;" \5 x- Z6 ^, E9 |/ X/ i
            if (lenA % 2 == 1)1 H1 O( X) M$ {( ]
                    reali = lenA + 1;3 c8 S- [1 c% T: B2 |6 T/ B+ ]
            else0 S* J. B+ p* L# e! w$ C
                    reali = lenA;
    . V1 K6 c3 l8 ?& ^2 J9 y        reali /= 2;! N6 s+ R8 }% `7 R5 u( T
    " n' F4 A7 {+ o5 w! _4 L% _
            int nconv = reali + lenB;
    % x6 R+ z; ?# q/ l$ l4 w) {% l3 Z- j        //#pragma omp parallel for
    % y* k1 `+ Z8 Y9 d: L! N8 A; W        for (i = reali; i < nconv; i++)
    3 @# F. M/ j+ a  @% S        {+ S3 U/ r8 g4 |# e5 p
                    temp.re = 0;
    & a3 w5 s8 C3 H  K) |                temp.im = 0;
    * g3 ]9 y; D3 I                i1 = i;& `( x' i' @/ [+ {! Y7 C% _
                    for (j = j0; j >= 0; j--)% O/ A$ x( h7 f( `9 F5 W% ?  Q
                    {; E1 y' i2 ?( w$ W9 c" p, J1 y
                            /* floating date operation */" n) y  b5 _4 O/ ?
                    }
    8 c4 E, V9 I* `
            }
    6 q! t. I5 a  R% ~! B7 V}$ V/ x0 N. @7 }
    / v, J$ H% X9 _# a. h
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    ) ^3 |8 n( u% L4 x0 I0 b
    & x+ x& H" A# t5 B+ L红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。! o* S6 J  l) m6 x: B: [& R  B
    现在call xcorr 100次,耗时78s.* ?1 g8 Z( x/ D; e( r; Y" z

    # `3 W$ V* z& l( _如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. # `# C1 B& z7 E( y" \

    / v  B( I8 O* p
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33' y/ j' U; Y# \7 M
    Maybe Debug mode?

    % ?1 W: U0 q2 P0 H! d( y; P: A
    0 c4 t8 d) \& R  ^) s7 T- R不应该,看我上面的回复。' C* w' i! b* @

    6 Y$ A. a$ T9 E! h+ e, B7 z, k我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 天前
  • 签到天数: 1934 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    $ }0 S9 o' c+ U" l" M  U
    雷达 发表于 2022-9-24 23:54, V( i1 \) i1 w: {
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    0 v5 h: j/ i& \& f8 W% l! j{4 e; E. c6 J2 _4 O
            comp temp, xtimesy;
    " ?2 h( ~  ]( J, f) B' e. N- _  w
    # b% }6 A. X" P, j/ N& Y
    这个不是这么比的吧。。。
      m& u# d' P/ J  ?5 L0 }! e" h# o3 @
    + U( p: H2 |7 |6 @& S您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    $ z& `: L7 f0 N# a4 v4 F
    . \( p* |$ l$ m$ t7 c而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 - N) j+ T+ W2 Z. u0 e
    数值分析 发表于 2022-9-25 00:20  @9 Y# e1 M4 @: z
    这个不是这么比的吧。。。6 N/ j4 }0 k9 }) |) W

    8 Y* j: ^# ^" ?9 l7 o: H1 a您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    0 \( V3 o% n$ G2 L% D
    & s1 t) R% D0 r4 s8 A7 v有道理。
    / O4 ]+ a+ v( n% n( q6 P/ P' ]所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。: f4 A7 ?# u" D7 D4 y+ z$ h, l7 e" q; |

    3 L$ H6 M6 B, B& ]* _1 Z0 _( X3 |我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    : j& j9 N% ?# a2 k9 |有道理。7 }/ G$ O& l+ z4 D' r: L6 }
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    ) ?# T2 v8 r& X$ r$ @你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多+ E. W+ {8 t* J$ Z6 N
    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, K3 o3 }, H/ ]6 c4 `& g这个不是这么比的吧。。。# U; U& j% a, ?" w- N
    6 s# s" f# s0 b8 ]
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    8 X5 M' Q) E) `! A. v9 \
    ( |3 Z. |( v' i) f/ f
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 天前
  • 签到天数: 1934 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 6 x" d& H# D* }
    沉宝 发表于 2022-9-25 01:48
    : K+ B) X( a; K+ A  ~现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    / }2 w+ {2 M5 @; p: w: ~
    ( ~2 @5 J: x% G4 K9 a! k! _是的,兄台说的对。
    ; g7 Y9 d- C, U0 Z4 E5 [, f4 p& o8 U( v$ d
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    + _+ a1 H- Z/ @* J4 p  M5 d
    ) N7 G9 S9 l1 O; Z# N雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    8 `8 U1 R9 v  ^  t3 g5 r6 D- a$ B0 m" O
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    9 H0 X/ I. V6 O& N! t6 M% E  Z  c6 O
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑   @3 p* k( d: v
    沉宝 发表于 2022-9-25 01:27
    7 w3 M* B# o( Z8 q你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    ) ~( e; n) i8 h1 [' U
    * ~- A- B$ U- \; H/ Z4 R
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    5 G; f$ S7 y) K& Q9 \/ |" L1 M4 U
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    + p- v$ L: {$ h9 k: R, W+ S时间差一倍的结果可以接受。$ U" {4 l/ `& @

    " `% j) Q5 a+ l5 Q* w+ E* U你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 天前
  • 签到天数: 1934 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 1 t8 D8 r: Y, F9 l9 W3 z5 o. S' i
    雷达 发表于 2022-9-25 04:47) D" N; O' x! V6 x7 D
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    * b: g1 ?. e7 U$ F; [3 m
      M- Q- A4 c; o! v! W+ V$ B2 ]( C$ ~* L/ B1 A' q3 l" J

    6 X, @1 e/ L6 s: y0 C) ]! J能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 $ M( a/ j) T6 [
    数值分析 发表于 2022-9-25 14:58
      V5 N) x- M# d" e; v" `: l# a5 ^9 A能不能把这个也贴上来,看看和上一个有什么不同?

    - h" _& H* }) y理了理思路,重新做了一个测试。
    + o5 x1 n" L* d5 e- F做了两个 vector 和 两个 float *, 都长 100000, @+ Q9 b- t, h7 u2 B
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.- A  q7 S0 V1 m; \) e
    # }' i3 r* X1 ~! e# A' G6 `0 l
    内循环试了4种方法,
    4 j7 g2 Y! J( y2 ~* n7 c* W% @1. 直接调用 vector inner_product 247s
    4 D1 `- }6 A  j1 d. W$ B, C1 B2. vector 循环点乘累加 237s% q  D7 ~* L' m8 q
    3. float * 循环点乘累加 204s
    % F6 t, p4 z' P" U  ?' A4. 空循环 100000 次 202s
    1 J8 |  o: @" u+ R7 c1 E2 I; U. p# W& w' I. X. [& ~  w
    不做内循环 200s
    5 {$ W5 h5 K$ E! _: u' G, C# Y/ T4 o) X& }
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。) `3 N; c3 G! U% K5 W$ A9 T
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    6 g% j9 }/ J" Z5 e' s1 O* D0 h6 W& g
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)- N, Y1 A" D+ h3 N
    7 Z; n; G$ x0 d: U
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    + x" _3 ]/ g9 g+ p0 m  A9 q+ I+ X0 W$ ~
            std::vector < float > vec1(N);
    , B6 S" I0 K! @$ @& F8 S- G        std::vector < float > vec2(N);
    2 h+ [6 h( r* k        float* b1 = new float[N];
    " q6 c. U& s! j2 J) v% w3 b        float* b2 = new float[N];! O- L2 N+ E/ ^( v& g( W
    ( g! x, _1 y" ^* N" h- V
            for (int j = 0; j < 6000; j++)1 @- K4 `3 w! T9 ?
            {) o! X5 C6 c+ v; u" N- B+ L# H
                    std::generate(vec1.begin(), vec1.end(), []() {
    0 @; g$ s6 G% k/ H6 f" M                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;' u: y. i# L/ [4 N
                            });: W& f; q& A  F" ~- }' n
    . H& A- w8 ]' G7 q  g
                    std::generate(vec2.begin(), vec2.end(), []() {2 f3 [9 P6 a" x
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    : `# ~( l  U1 V( K- _, v                        });8 [% O5 ^0 ^( u, `! s( i9 t+ o
    + b7 L2 [$ R2 B9 `( ?
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    8 K; B. g& Q% z) f9 @6 [( Y& Q                {$ |0 g* V. p- C5 V5 Y6 {; y' c  V
                            b1[jj] = vec1[jj];0 c4 E; ~$ j/ V3 }# R, C& Z
                    }+ I  _  F1 t1 \3 q
    , I+ i! L+ N4 D
                    for (size_t jj = 0; jj < vec2.size(); jj++), y/ l4 F  e; U. q2 C5 x# [3 k
                    {
    ' ?: V' Y  |2 i                        b2[jj] = vec2[jj];
    6 r8 m* c) r2 T; M' Y+ v5 B                }* l8 }" ~3 G  K- j2 A7 Y) T
    0 j" R9 R& i# j
                    //Method - 1  N=100000 247s  
    . k# @9 R4 l/ I' w6 {' q$ T                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);/ o6 i2 F( d- w' K& g; }
                                    4 h( f5 Q+ @6 U- o/ b
                    //Method - 2  N=100000  237s0 m8 b& K( P$ a7 J9 G. ]
                    /*
    4 \; F: ~! [- X# w+ g                for (int jj = 0; jj < N ; jj++)* N8 @( I- Z0 B
                    {- i. B: W. M  E  n  N$ X
                            fresult += vec1[jj] * vec2[jj];
    4 o& _; g) f$ P( K& N: f                }. _5 v6 |1 I+ [/ I: V$ M- k, F5 T
                    */
    5 D( v: [+ @  x8 f" C- Y: d                                
    ; k8 p+ X) F% D2 Z' w% A& L                //Method - 3  N=100000 204s' G1 e6 U9 O7 H. J$ T) R. i& k
                    /*
    1 o& G8 X! K; e, W. d9 L7 S; Y& i                for (int jj = 0; jj < N; jj++). n8 ~" O6 D; S; e" {9 Q8 V& A' g
                    {! D% E7 F) k  _7 S* a
                            fresult += b1[jj] * b2[jj];8 y$ I& q: }+ O6 Q
                    }  f2 e& P* M/ a6 {
                    *// w' f# r$ [& p, X
    4 G0 Y4 o' P0 @  }
                    //Method - 4   202s. c6 t& k, l0 G9 E
                    /*' v' O* S' o$ R/ y' `8 \
                    for (int jj = 0; jj < N; jj++)
    * C' B, \+ c$ L5 P& n                {
      p  A7 l/ e. R9 d# ^1 F; f: i                        
    # A3 s  D; H# V- b8 V                }
    + z" e  R: }' h( V; ~$ l                */
    + B- [# N, U0 ?7 J' N. p                //comment out all methods, N=100000  202s                ; B6 }9 ?( U- h2 }7 L. h
            }2 d1 e  i6 R# l- ^' G! K

    , u( F  o# u- p0 b2 _4 W        delete []b1;$ ?, V* U" w) U: ~& g5 C  L9 \
            delete []b2;
    4 N( @$ Q8 F, V: A* J0 T
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?' N7 Y* d" x0 k/ t  k

    : ^6 @1 z( {! [你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?+ T- b8 r" L- z7 X9 l
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    6 [( I3 h8 ?) X$ Y' I$ }瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ( j$ X# G+ M) k/ Y% k: x
      Q5 a  I5 w8 b# g0 M你第二个试验里面的j在循环里面又重新定义 ...
    $ |5 C6 r6 W; j6 ~6 v+ @  A
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    , e+ H* ^: I& h5 a7 F
    7 B7 C2 k- D; F+ p6 ~2 M. v不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    . o% A/ L/ c& Z, Z3 {8 |& L内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    + A5 |7 v/ s1 g4 k5 E. o0 [8 c: u" O
    不和它 ...

      h# A3 ~/ G# g. m0 E- t
    / c+ m4 `+ c: u2 M- d" p: u不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。( B3 c% L5 C  T: c
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:545 r5 \3 C/ [: ]
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)7 H3 U) u5 ~# a# B3 W
    {0 K/ M5 Z- h& ~$ I
            comp temp, xtimesy;

    9 ?* ]+ O& u8 y5 S  ~/ U5 C- y这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    0 c1 |, Y6 S& x: t/ z2 t内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?, T4 X  F  Y7 }
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-23 14:46 , Processed in 0.078337 second(s), 21 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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