设为首页收藏本站

爱吱声

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

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

[复制链接]
  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?$ b* m5 P5 S% a) ]! G3 Q

    + u1 [! m4 t% ^, x0 O自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。0 z8 j, }  j/ w- P
    - t. |0 o! z$ z; N0 L
    速度优化问题真的很有意思啊。
    . M% Y: X3 c" E& D7 b6 q) U+ o: _5 t
    3 o* a* o# [  X3 e* y欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    7 c8 W/ Z+ H" Q5 T* B" p把代码贴上来看看?
    + a9 g& ]% L4 ~& j* ?- X9 I) p/ @; |5 I$ \
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-24 07:04
  • 签到天数: 126 天

    [LV.7]分神

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

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    * P  M: ^$ t; ~$ n
    数值分析 发表于 2022-9-24 23:04
    4 Z) a4 @8 T. R拉下来?拉多少?, ^" q( w) g- [/ y2 \& h9 q
    把代码贴上来看看?

    / ?& P: ]# p2 Y) r; |( B. v4 e+ @6 \/ L  d
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)7 C# k. i7 q2 ~: j
    {
    - c5 L0 M* ~3 M        comp temp, xtimesy;& e, Z; T% p& r4 B
            xtimesy.re = 0;. _& [5 p5 ^; p6 h5 Q
            xtimesy.im = 0;8 Z0 @5 x1 `. r3 j" D+ H0 O
            int j0 = lenB - 1;
    3 q0 F9 v$ Q. U        int    i, j, i1, reali;
      r/ f5 s+ i: j9 g        if (lenA % 2 == 1)
    2 {! D* a8 l9 ^7 I6 w5 V                reali = lenA + 1;* K/ T+ R; |4 Y$ m, h6 ?/ w6 ^
            else. u, v* c8 T- K$ G; K. V0 B
                    reali = lenA;$ {$ h! f( k/ |
            reali /= 2;
    2 n: [$ ?2 O* A  R
    * X  i, k- _1 \4 X. k        int nconv = reali + lenB;
    4 M. i6 ]2 f: {  K- \8 D        //#pragma omp parallel for
    1 p5 R0 R, |0 [: S7 j; W; B0 z7 l+ {        for (i = reali; i < nconv; i++)* t+ K. n7 @$ p4 @. \
            {
    ; s6 ^. E* K( _  {; j  t9 y                temp.re = 0;
    # z" M2 V; v% m; p                temp.im = 0;
    : G# s) D- u) _5 g2 d5 ~                i1 = i;
    2 |, ?" s4 C% }; x. W                for (j = j0; j >= 0; j--)# k# Y2 A( q  u- A/ ?
                    {6 b- P' |0 o4 G
                            /* floating date operation */
    3 d3 a7 L3 ]- o                }
    ) E, N$ ]; [# M8 y% \0 f. M' K1 ?- Z
            }+ n) i/ t2 w8 E; K2 I2 J
    }4 X  D5 Y& J. T: C

    $ S5 n) U- |" O/ A7 }: Bxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    # E' b2 i) G6 M: C
    ! f8 z- I* i  l; p) ^( q, u红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    ; A8 w& V6 E/ E* p5 o现在call xcorr 100次,耗时78s.6 h) [4 S  d3 p$ J
    2 q# H4 z" N3 C8 b
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 1 R8 U6 r/ ?5 D( x' O$ Z
    7 ~2 w' z2 T5 U8 g
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    . W: H1 e, L( i5 t5 O2 SMaybe Debug mode?
    5 M4 N+ \- i5 P8 t$ F
    8 N: L/ z3 ]7 e; {
    不应该,看我上面的回复。
    - m+ A( \" J) @  W6 {' j6 u! H. ~4 j: [5 ^- l7 B! X" Y+ I
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    ! j" s4 d  C0 [" Y  u9 u; ~5 _" B
    雷达 发表于 2022-9-24 23:546 }9 `& O. {5 b4 O- c
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    % Y/ Z2 B& U1 T4 V  n{
    + y0 \( Y+ T& A+ V        comp temp, xtimesy;
    : k6 s+ p. }# a5 T/ B

    # h6 v4 @# k4 h5 p这个不是这么比的吧。。。$ U( P8 a- s/ j
    7 K, ]+ S( U9 C! f+ `
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。0 U4 {5 r: d+ y9 a& j3 a4 q
    7 w, \. i) X" X/ Z" N) G
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    5 Z+ ~* Q* X% `
    数值分析 发表于 2022-9-25 00:20& v' d3 i$ R/ g0 c
    这个不是这么比的吧。。。
    , R8 t, x  X- K
    ; {9 U- N) T: K- U( r, q. U8 I; {% _: [您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ' ^0 U. V/ o2 [8 m$ i' R0 \/ M# _# v3 m5 T  [/ r  x
    有道理。8 F) b  y7 `0 s2 M& p
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    ! O$ [% i5 L  V4 G* f
    , G1 k+ u/ e1 g我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    ' ?: b: G- N/ [) s8 d8 G" I; ^8 \有道理。$ c0 v3 B8 H7 A
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    ) Q- n5 m+ B" Q+ s你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    ) g' b$ {1 m2 B) [1 U. J: QWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:204 p7 d# E9 L7 \
    这个不是这么比的吧。。。  Z3 D) u  c$ J! P& \

    $ j* V3 [( i# x! T" c: t7 _( S您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    2 L# G& |1 P# w4 Y" M; R4 T9 ]
    $ Z5 L6 {2 N; |' `
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    $ D& m4 T3 |  ~# |
    沉宝 发表于 2022-9-25 01:48
    : ^. Q! [) P7 o8 E现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    # U, p# J7 Y: w* B
    9 z) d8 ]7 k0 Q; ^' @. e* M
    是的,兄台说的对。: {4 W% [+ W  \: \

    ) w6 w: z/ q2 S9 n/ D4 D其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    # C! T3 P' C% N, n) k5 A4 V$ \+ [3 e. |. g" s6 ?
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    3 x5 Q0 {- {% k: s* {0 f' R9 t9 n) ~; h
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    4 \. h# x3 Q5 [0 v; T
    * J2 Q! Q' O- W- Z# G- ~( ~当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    % P6 P0 P* C$ O- A" y5 }
    沉宝 发表于 2022-9-25 01:27
    6 _# L3 I* d. m! S- ]# F! B5 u; n你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    * o" R8 O3 h$ F. ~# n
    . `, Z' m  n% G3 v3 j6 ^
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    " {0 Y' ?1 W4 X( ~- b5 m) g  L1 T5 g9 }2 ~: a* x, H
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:474 A3 V+ k3 g  H9 v! X
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    & j3 L) x& e. [  ?3 P2 z" ]: C. ]" Z时间差一倍的结果可以接受。6 j( K3 w# j7 J' B

    4 U# n# Z6 d. G5 d- [你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 3 ^: }! t' P2 Y" d3 P: v
    雷达 发表于 2022-9-25 04:47/ ^5 g/ j2 P4 H2 t0 G) r7 J( P
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    4 S% o1 L, d, Y7 ?8 N

    ) h/ M" K3 D5 m( a( p: I0 |2 ^9 }

    0 C0 S: l* u2 b1 W: y能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 ; }, ^1 e! e; Y: Q* X
    数值分析 发表于 2022-9-25 14:58; X3 R+ ]* H; J" \, i% I5 U
    能不能把这个也贴上来,看看和上一个有什么不同?
    7 z3 d0 g* v; e3 f0 L% i
    理了理思路,重新做了一个测试。# N3 x& M$ F! ~/ v: F! u8 e  x
    做了两个 vector 和 两个 float *, 都长 100000
    / r7 W" H7 }3 n# Y, M. X9 u外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache." \* R) `8 t! M( {$ h0 Z

    6 Z, t! {+ L9 B3 E6 ?0 K7 Y内循环试了4种方法,
    $ h4 L# u( p! J, b' T+ d, ]9 q1. 直接调用 vector inner_product 247s 8 G% z, |5 h4 N/ A( @
    2. vector 循环点乘累加 237s
    : Q9 |) q4 L8 t9 o/ E& y$ F% {3. float * 循环点乘累加 204s, g" O. }$ E  E% ~
    4. 空循环 100000 次 202s) J$ I/ D# t9 u/ B2 a& k2 g/ f
    8 [2 x( S. P8 K7 R0 b
    不做内循环 200s
    9 G) i& [+ S, Q' u* J* M3 I4 {( r/ q9 m/ T
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    ! a4 `3 q$ m  ]另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。5 N1 g; p/ }3 ]' ~# T  D% y

    $ J5 n  I9 \  {9 q. I& h& h$ }* B9 p至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    4 n1 q2 l9 G- {9 t( x; [0 Z
    5 m% {3 e- Q3 y$ e% K5 x0 O7 q  Y(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    $ O# u" z4 _3 D* ?* |3 W+ ~" _1 o' x2 J$ [* ~. M
            std::vector < float > vec1(N);
    % F/ x8 N' P( o' X2 |3 J  m        std::vector < float > vec2(N);" ?* s- r  x( E3 z: F
            float* b1 = new float[N];  D. i6 A& R* A+ I8 Z$ u7 d
            float* b2 = new float[N];
    ) f/ {! y5 A; A
    ; J: f' }- y% j7 `7 I' c- ~% ~        for (int j = 0; j < 6000; j++)' c. |; C0 q* W& Y
            {
    7 A: \$ H* |5 Y) J: M                std::generate(vec1.begin(), vec1.end(), []() {
    ) \; k; j* V+ m' _# V                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    - x  L' i# P% t! v                        });
      R' E) R! p& `, H1 p+ Z' F* e5 i* ~1 H3 R1 _- e( [4 U
                    std::generate(vec2.begin(), vec2.end(), []() {4 x& U2 D$ W, S4 L. T" ?; M& ]
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;4 B. B( v+ x+ y/ y
                            });
    ' a( y  G8 U$ g6 M: E) ]' a
    ! }4 v& F2 R  ^' w8 B+ E                for (size_t jj = 0; jj < vec1.size(); jj++)( P: `# i5 S/ ^) x* h7 @: f. S
                    {5 ~5 U3 {: G4 b
                            b1[jj] = vec1[jj];1 q$ u4 p1 y( r1 A
                    }
    5 v/ P, @8 A0 x2 l: r
    . ~! M+ n  g6 s8 D6 I0 i                for (size_t jj = 0; jj < vec2.size(); jj++)
    7 ^- u6 q  i% M* c" N1 \, p# P                {7 @4 L* R* S) O5 _1 w8 J, o) ?( [' U
                            b2[jj] = vec2[jj];# U7 q  }) N: R6 J  X
                    }1 i4 r% ~8 Q/ D4 y( Q

    * ^0 ^2 V+ s" A- G                //Method - 1  N=100000 247s  
    / _6 d/ G* [* A; b6 c                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);; A3 ^8 b& r+ D( y
                                    
    : S0 z/ Z6 E8 G/ O                //Method - 2  N=100000  237s( g/ S7 T1 _  h! P6 C
                    /*" L4 K: _- W2 `) Z: Y5 Y
                    for (int jj = 0; jj < N ; jj++)% v6 G; [2 Y5 M' @9 z  n6 \
                    {0 o0 Y5 W: e$ P- h/ a
                            fresult += vec1[jj] * vec2[jj];" `$ A. G" v, `" _( z' C
                    }0 m, L# u2 s: b- Y& R7 {, m
                    */
    / Z/ f0 r' K! H, S' r: ?) q/ v2 }                                
    7 g! \' T( N% x3 T                //Method - 3  N=100000 204s
    7 V- X1 e4 C4 b; J7 Y, o                /*, }) l9 E* J9 f7 s) t$ F
                    for (int jj = 0; jj < N; jj++)  q: `0 a+ n/ q7 }, w  P6 d
                    {
    # U( N: m. A, S5 r7 E0 Y                        fresult += b1[jj] * b2[jj];' |  O2 f3 P$ ]  F
                    }# E3 _, U( c. {( v; J# C
                    */
    / f; X; E0 j& K, a. X3 v2 ^4 z& S: F% T
                    //Method - 4   202s% Z$ G) e  S/ W! u5 M
                    /*
    & \6 h! N$ |8 W% C+ A: o                for (int jj = 0; jj < N; jj++)' {8 @/ @# B. I+ N1 N6 c7 M- ?
                    {) V) K& k& }, y; P1 Y! B2 Q
                            & c" l- k6 g, v
                    }9 |/ f  ~( A  ~$ @% D) Y5 c% V7 s
                    */3 \. K5 b5 j2 L& B
                    //comment out all methods, N=100000  202s               
    ) X4 Z5 H. J. w9 D+ @0 c! r        }/ |/ n' i6 ^# A" S) i6 p; m3 _% ]
    ! }6 L" \9 A: w* \0 a5 u
            delete []b1;7 T' ^% e6 z+ s3 r  A' l' G! t7 R
            delete []b2;

    , r% b' Y* p* N' }' ?
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    2 q3 \7 Y' ^& ]0 ?2 W
    - S  k! ~% x1 n3 s5 e% o你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?1 _& u. N% k7 N1 s9 h% t, g7 l
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15- w+ s9 c4 D5 P, i: p8 S
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?& O. @$ I* C5 B; K, z; K0 {

    9 E3 R6 B6 d$ D, k0 Y你第二个试验里面的j在循环里面又重新定义 ...

    : L9 L* c* J( u& d内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    . e) e# ^" t6 [; |/ j" ^8 K# S; R! H  P- g
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ; {  m. a& A( }2 E* B) [4 O内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL  a4 }/ x0 m' ^; y1 O) S$ `
    ' ]" P' f% m" p# m0 m. F8 O8 y
    不和它 ...
    / ~; W5 P# M0 {' P$ `
    ! n0 r! R2 z' l" t2 S
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    / y- |; d2 t% K! t* Z后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    9 S: p, U+ P, K. ^5 ]) j) Nvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    : y7 F# l; Q& z" E# R% Y' O{% Q# \1 R3 L' L8 D$ f# m( U
            comp temp, xtimesy;

    , o4 ^" [5 W7 I. J. i这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。' b9 H, Z* N; Q; E1 f3 k2 N
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
      _& f. I6 {- B! N3 sVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-7-21 17:50 , Processed in 0.072690 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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