设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    0 S) f; i: Z% N5 f
    ! r; u' K. v8 [自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。: `: N0 h3 E6 K& z  C
    6 C, b4 k# V" ?  @
    速度优化问题真的很有意思啊。2 p- b0 O2 T6 j6 T

    & N- g, U' B2 P: C/ g欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?( f8 \$ b' L2 G9 X) v3 \% I
    把代码贴上来看看?
    1 @* C' \$ o/ b3 L# J% G  n0 O% F
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
      O$ Z* e2 L8 T1 h
    数值分析 发表于 2022-9-24 23:04* {; A7 e0 j  W
    拉下来?拉多少?- C( [1 i; l3 s. C3 O) m% M/ [
    把代码贴上来看看?

    + y" ^* S3 ]7 f. S5 a2 j. I3 K, Y" t3 B9 h$ ?! T7 L
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    + I4 ?2 x# C5 _' {{
    2 q: r! t' [! W5 _# ?8 a        comp temp, xtimesy;/ o+ ^8 B8 d& d: w
            xtimesy.re = 0;
    " Z- l1 K5 A0 ~. ]* w        xtimesy.im = 0;, A2 ?9 k- q5 A6 Y: a
            int j0 = lenB - 1;
    & j. N3 q. A" f5 p0 x  h, J8 A        int    i, j, i1, reali;5 D' s6 @. G# ]* X5 S
            if (lenA % 2 == 1)
      S0 ]3 A5 l  ?% Y$ D/ ?# U9 }                reali = lenA + 1;
    ' H' \. h5 i. R2 t- M        else
    ! c3 O; V) S7 l$ a! M$ t! e5 D                reali = lenA;
    * y! K5 v1 |5 [) B: n        reali /= 2;9 I+ x$ N' V6 ?4 z
    ; i) P/ P$ D+ {* b) w
            int nconv = reali + lenB;& D6 S, x# s  }0 z  b
            //#pragma omp parallel for
    + k/ X0 Y- K  t' N/ _. ]        for (i = reali; i < nconv; i++)/ m, j5 U# m) ]8 m8 m
            {
    - j0 @8 F4 ]7 B' m( J3 L' j                temp.re = 0;
    / O" J/ y6 m/ J# _7 b" ?                temp.im = 0;8 c4 L# ~. z1 A8 o# N
                    i1 = i;
    2 s+ M! S: C1 E2 s                for (j = j0; j >= 0; j--)
    - k0 _- E4 g2 m. Y" L                {
    ' Z& _7 @0 @, X! c& i                        /* floating date operation */8 g4 G6 s" u0 `  M4 E4 T
                    }

    * I; _( m/ R1 A) x* ^        }
    1 E# K1 u1 B5 o$ V1 i6 C* \) m5 W* S}4 N6 e! k' O/ }! o
    ' \9 O" P! P8 A/ F& M
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样5 J) p8 J1 ^& x
    3 r3 w' q9 m7 v) A
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    4 S& W, @$ {4 J7 p/ [2 H现在call xcorr 100次,耗时78s.9 O* s' M2 d. G; J2 X3 @

    / r% |) j: G8 D5 M! Y如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. ; c, E/ \' G- p/ F' ]

    & @4 M$ D0 W' [. j! ?0 {
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    ( m& o. u) ?' `Maybe Debug mode?
    , d, B  P# G% K- b  x! Z9 S1 f
    $ [/ _# u9 C4 F
    不应该,看我上面的回复。
    , [- b8 C8 c8 W" M& N9 \  R9 c  |
    $ g9 N" j) D9 H' T7 E! d我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 4 Q5 h5 k2 P; q# ]$ w
    雷达 发表于 2022-9-24 23:545 u/ I" b4 s' X( p! l$ K
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)6 x1 f% F4 L3 w9 m! Z, b; M
    {
    , N2 u# F3 V5 q; M$ p( M! x6 b        comp temp, xtimesy;

    % i$ k3 B' g- A, s9 ]2 s1 d8 t' B, D% `& G0 X2 Q
    这个不是这么比的吧。。。! _' n+ l- W3 `

    / ^# B# Y( \& B2 j$ L" q您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。; F+ J$ U# `7 h) I; G% O/ {

    1 b- b0 N6 N3 ^& f) i3 o9 T而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    6 Q# |' u; J: q0 Z( a) ^
    数值分析 发表于 2022-9-25 00:20
    ! \- m* I7 j/ F' ]3 ?这个不是这么比的吧。。。
      _  z6 j" v/ B/ t! d  m0 B
    7 p; O$ y; C" t# @2 P您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    8 D4 ^- r! c  G" {3 e
    ( Z; V8 a1 r  }, h' o有道理。
    3 I+ x" L' z2 T0 h1 E0 P# N所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。4 i8 m9 |9 L1 P" v
    " z& t, F4 Y! u9 Y& M
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    4 e4 r# i8 I% L. x: X有道理。6 |$ h7 d$ P, s5 |' g" r$ a
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    " ]$ E% V' d0 u& Z3 o你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    ) N" q+ E6 ^* \+ XWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    ! y& n/ k% {- L; {这个不是这么比的吧。。。
    & s) v' E" j2 K: ?  y6 P, j  Y# ]& t5 r; ~$ w3 ?! m1 R" x' T
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    ( P# e4 N. }- y. ~* ]$ r" g, @* [" B& @5 b
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    2 O# F/ i' @1 N7 i- s. g! g4 |
    沉宝 发表于 2022-9-25 01:48
    ) ]3 {) X8 N; M  E8 q1 d$ Z0 ]现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

      r! ~% ]1 L8 P; V5 w
    * j3 e6 d! N1 S: ?' Q' Z是的,兄台说的对。
    1 j2 H4 E% p: N% J. v" r, w
    9 m+ F8 F" m: o& e' ]! m! n其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。8 ~0 b1 r' g5 I1 k" K
    $ ?+ |4 K+ m1 h7 E2 Z4 D9 {! w) e
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。6 h/ _4 ~! F. D8 P% x( G

    ; V7 z3 X+ ^, i( ?比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ; m8 W- c. f! D0 h8 F$ @
    ' f* a" p: d( J2 M当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 . y5 f6 O" l' x1 ], @
    沉宝 发表于 2022-9-25 01:27
    6 _/ v9 o- {. _" c! }! _你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    4 ]5 o3 j) `5 q
    3 Z  b0 d! x" f! F$ I, L: }% g/ M
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。! h6 d6 z* C# v- a

    ( o" ]0 C- p4 m" k) j2 f" r& J我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47: S' L; j: F3 E& q+ ]9 e2 m" L
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    - ?8 M9 D6 [; c- y, P
    时间差一倍的结果可以接受。
    3 Z1 Q( [6 X$ R* G, A1 e+ `: l0 m( `" `  A
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    % L3 |( g$ G9 V$ M" e/ H, w0 l
    雷达 发表于 2022-9-25 04:47
    ) g9 g1 B. R8 v9 k) z9 K9 ^又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    $ V  ^+ Q2 x( X# J# a2 L# R9 }( j+ n" F; P2 R

    & v8 L4 C2 B; J* ]2 O
    $ ?' T7 Z' g- S6 v& l5 x& V能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    , U  V. {: j4 M- R' l- ]
    数值分析 发表于 2022-9-25 14:58
    1 \! V/ V( Y$ y8 m6 T能不能把这个也贴上来,看看和上一个有什么不同?
    - k) O% l- K- h5 ~4 L
    理了理思路,重新做了一个测试。
    6 [3 j; ^# U5 L# z4 _9 o做了两个 vector 和 两个 float *, 都长 100000
    + P! i6 p4 u( @! q( S( O8 e外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache./ `3 G2 v1 y* G2 W( d# `* ]* B) L# i
    6 s; t# T9 C+ v
    内循环试了4种方法,8 H( R# V, @3 H9 v
    1. 直接调用 vector inner_product 247s
    3 a% V: c. \! c2. vector 循环点乘累加 237s) w* m- X. V! Y5 o; o; s0 N
    3. float * 循环点乘累加 204s
    * O' U+ {0 p1 U% E. k2 P6 i4. 空循环 100000 次 202s5 P' R. y9 S- t- L
    . c( p/ u6 w  Y6 j
    不做内循环 200s% Y8 ]1 }0 q7 F  ?9 A
    , }' L% G5 p7 @0 [, x
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    ' N" r/ r  k% X8 A& {另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    % p( t: X. g, A" E2 |
    % `7 g5 o  U0 i) f: l% ~* O至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    % W( y. T0 _& m! T0 m0 g# }5 W6 H8 v. I4 R& r& K1 y
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL); A7 z$ Y: F7 I) Q
    * n. ~9 F+ a+ d- s* n: i
            std::vector < float > vec1(N);% |! d1 E) o" Y+ N, Y7 H6 G
            std::vector < float > vec2(N);
    ) T1 _% ^6 n9 F! ~9 u- g        float* b1 = new float[N];
    + F8 }3 r8 I) ^% U: l- t        float* b2 = new float[N];+ u" o1 X8 a, b8 ~% {
      Z  `6 }7 L$ Q$ T7 d- ]
            for (int j = 0; j < 6000; j++)
    , ^" q1 F1 I3 |' I% j        {9 ]+ E" ~8 ]6 ~) Q* p
                    std::generate(vec1.begin(), vec1.end(), []() {( R% E1 H1 T7 \9 j9 ^
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
      |0 k2 X: X0 M* i9 v- u                        });
    $ a0 T: G+ X; F& U& I2 H: {: t# \+ j  e
                    std::generate(vec2.begin(), vec2.end(), []() {4 `* G- f: Y* U, R. _; b+ X
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;# q/ @2 n0 Q7 J- J' L2 A
                            });7 U( I+ ~5 B! H8 W' `
    1 K+ I8 ^# t0 U9 V- S) z( N) P
                    for (size_t jj = 0; jj < vec1.size(); jj++)5 L  R7 G# m( L# q: x0 Z. f* ]. Q
                    {
    ) I: u4 S4 @6 E9 A) G: Q  v* S                        b1[jj] = vec1[jj];9 i, \) b+ a* N
                    }
    & N! Z3 |! J; w
    4 H+ [; [) x7 a6 x                for (size_t jj = 0; jj < vec2.size(); jj++)
    9 ~4 n, A( @* w. C                {
    & H) g) N; m" w. t' r# j                        b2[jj] = vec2[jj];
    7 S% l  G, U7 j) M- o# U2 c                }6 A$ w& o& t' l+ R9 ~, i; F" B- U7 v

    - f- P8 v" K# @- O                //Method - 1  N=100000 247s  1 q' s+ v& s0 P) b" \
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);, g4 A3 x+ u3 S- g! r" q
                                    8 f( h( z! [5 h3 S' g
                    //Method - 2  N=100000  237s
    # Y+ z; R- h& L0 W) ]                /*/ V6 V) d6 T  c2 }& p
                    for (int jj = 0; jj < N ; jj++)
    8 [; I# U8 U! v1 E0 Z7 `; C                {
    + }* ~6 {5 b3 c                        fresult += vec1[jj] * vec2[jj];
    5 I0 z) S; F3 G# c+ ~0 U                }1 m7 d/ O4 ~0 ~1 D" z( Y7 [# h; |
                    */$ [  G; `! h- E
                                    ! ]% v; p: y+ N+ ?( B4 ~
                    //Method - 3  N=100000 204s
    . T4 a5 A4 i! Z) O# @! q9 c4 g                /*
    $ j# h* a. [5 s/ r                for (int jj = 0; jj < N; jj++)) B) V" T. }; f3 C- T; V2 B  U
                    {
    7 E  ^3 B. F( ^- T3 K) M. c' B# r2 K                        fresult += b1[jj] * b2[jj];4 K% g7 u4 E- K$ K8 W
                    }  @' ]8 Q3 I* n7 F* r2 Q
                    */
    1 M4 ^! c8 {. C  J" r+ Z5 g7 c0 x- V0 w. }) Q  q( W
                    //Method - 4   202s2 J# k' ]1 z4 S1 x- N0 h9 [& A
                    /*
    ; ~: |" ^0 ?, g                for (int jj = 0; jj < N; jj++)' i/ Z: v4 D" _& l& S
                    {$ j' f  N! C# p% M
                            9 C6 G9 i( c4 x
                    }  ?# R% @( `! E6 w4 [3 F
                    */
    % s  C  X, K; q2 V" A- {4 w                //comment out all methods, N=100000  202s               
    # B* K) |0 R' V        }
      W" @2 [0 ~9 Z/ U( C  \0 n  W  o( \( Y; E/ d6 X% h
            delete []b1;
    ; B6 H: {  U" i: g8 Y9 t) s# F        delete []b2;
    4 ?. O/ }, a. K/ }/ H
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    " L, A! H" Y) Z8 P
    ) Z/ f/ p+ ^% ~: k; g  S' [/ h; Q你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?6 o8 _2 r, ^5 C* N
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    5 X: N9 N! I2 i' H瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?2 s3 y8 z+ c4 Q! K' L! W/ b

    ; G/ I5 N* y; K你第二个试验里面的j在循环里面又重新定义 ...

    ) |  H  B& X. S+ ?! s内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL* }+ E' D/ Y+ C: S6 Y
    $ C  ~- s7 J3 Z, L( ]4 }. ?8 f2 W2 J
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ( i7 k4 K; \9 h3 F2 w5 s" u内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    . J9 T9 Y, R& _3 [8 e8 @' f5 P1 \, v+ {7 I& B
    不和它 ...

    6 T( W" U; n+ [, t* f/ x  z7 e
    $ Z$ I! h9 ?4 |: M/ ^1 j/ E不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    4 ~' U- Z! f& z5 ?后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54; m0 \6 ^5 B4 s& V" W' R; @
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    3 G" z8 A4 T' L/ ?* s& m{8 T3 g5 e3 `# @6 F( P9 U
            comp temp, xtimesy;

    - A1 N( S3 h, R0 R7 z* `这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。! s/ ^1 Q: t7 a; J+ P+ @
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?7 U, I, y% p6 j1 j3 f! L9 A
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-9-19 09:02 , Processed in 0.072910 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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