设为首页收藏本站

爱吱声

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

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?; J& S7 y+ I  s; a/ p
    4 a- M+ c; t: G
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    0 z  N+ S6 k+ h% z7 v$ P5 d
    ( f8 U9 E4 F1 U, w* A速度优化问题真的很有意思啊。
    $ N2 Q& P- L# j# m( R
    ' u8 `! ~. X9 I欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    2025-10-27 04:12
  • 签到天数: 1953 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    % v* V7 ~5 |, Z8 a$ y8 {) I: `把代码贴上来看看?. t& ^- |; S. |/ B0 ^, q8 X; k6 u1 e
    $ d  u% Y" G+ d( I9 L# a
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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的每日心情

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

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑 2 x  K5 F1 |  ?) S: j
    数值分析 发表于 2022-9-24 23:04
    % ^$ U# C/ G  q2 J拉下来?拉多少?
    . l, w1 B8 U. F7 O' A# M把代码贴上来看看?

    - }7 ~* ?3 s" b! I5 b+ `& [9 @/ l- R
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 d( ^+ c0 z8 S9 w; s! N4 m
    {
    / Y+ j- ^. W: Y1 h2 Q; @        comp temp, xtimesy;$ P3 e/ D+ ]3 A8 m
            xtimesy.re = 0;
    / H: d0 D, F5 P' [        xtimesy.im = 0;9 P" k1 l- w+ i: ~) \4 b4 |
            int j0 = lenB - 1;$ Y1 }1 ^3 y4 K, o  a2 G
            int    i, j, i1, reali;
    # ~# i7 n2 o  s* `        if (lenA % 2 == 1)- p1 a- P4 v% e
                    reali = lenA + 1;3 |! n6 ]" c( L" S% `# C6 a+ n
            else* ~& L' X$ m2 e% \
                    reali = lenA;0 I; X" ]0 a4 |: z0 G6 O) ?0 |
            reali /= 2;3 b5 Q- U' f; d4 g. I/ G
    1 H1 e4 n. e2 _% t, a7 d
            int nconv = reali + lenB;  C  d: d% ]' z
            //#pragma omp parallel for
    2 c$ m3 B9 k7 z, ]% z1 n9 A        for (i = reali; i < nconv; i++)
    3 \8 K8 x9 F6 l( Y7 y; s; Q; [% q: ?        {6 R% t$ Z. K6 f# q( v- [" d% m' ?
                    temp.re = 0;7 E, u. j0 y, G* @- J5 }
                    temp.im = 0;9 Y0 p9 Q* B9 \
                    i1 = i;) t/ r" G) \" s" {" R
                    for (j = j0; j >= 0; j--)$ s. _0 E9 |0 r' ?8 e
                    {+ E7 ]( a* F9 I
                            /* floating date operation */
    ' k: y) b* U# U+ F2 z                }

      m3 a1 s. x, g+ Y/ A  s        }
    6 p3 H8 P8 {  |4 w6 Z6 P* o2 u# h}) [2 f) A' P+ h! X( o! I$ Y
    : T8 h. f$ f5 j3 \! I
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    : I; \7 ]0 |* J8 ?2 [9 V$ b3 s+ L7 |2 j- r
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。2 n7 Z4 F6 n( e/ `
    现在call xcorr 100次,耗时78s.' q% v: e& F% v0 s

    0 \; t, b: S. k! r/ r如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. / k: M/ V# d' A2 y7 |
    ) Z+ ], z+ H" v# F6 W8 e
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:335 R. h( o8 E6 L  z9 t
    Maybe Debug mode?

    4 f8 Q$ O- v. ^: n# K  R. G* V
    ; u. h  H. q6 @  k6 H4 `不应该,看我上面的回复。
    $ [0 V1 S& F7 }/ ?# U
    7 G  ~1 n* h& c' g3 P# B6 h我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2025-10-27 04:12
  • 签到天数: 1953 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 0 z) I- }3 m8 U
    雷达 发表于 2022-9-24 23:54! s+ Y, ]" ^1 b6 r! V% k
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 N  C% B: ]3 t  H) d* z4 ^3 w% w
    {
    * v4 Z! M- J8 T& F4 _9 b- N        comp temp, xtimesy;
    " o. Y/ C- ~& `8 H2 @
    ( g3 y) m  j# ?  V
    这个不是这么比的吧。。。7 E9 z( M' {' Z, D- m

    % K) K" L9 U9 H- |( R您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。+ {7 Y. M1 F6 f5 L) e7 u

    / l4 W/ p- O2 _" z, Y而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 8 k" q! s7 H/ j
    数值分析 发表于 2022-9-25 00:20: `" H/ E- g; _- D) \" g2 }
    这个不是这么比的吧。。。4 Q' Y) K7 F5 l) k! D- n$ i

    5 T" Z9 u3 n5 M8 Z" Y+ c/ L) r您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ) z3 H' C% H% K& v4 x% e8 }0 A/ m' J! B: N) J) b' M
    有道理。
    2 ]7 L) v# A' s( ^7 a' L4 p  i所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    $ o$ Q8 |3 |: Z2 `: ^/ W4 P5 T
    . q! Y9 P: b* C( y6 N我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    6 z) q* l/ ?7 a+ {有道理。
    , e6 C8 N; `# }: e# y2 m所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    & C$ @- s! Y; u( Y% E3 B9 M
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    3 e8 R% _+ i9 C" ~) IWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    * l6 F8 I, [' j1 [9 |( i这个不是这么比的吧。。。" u( v! }% x/ y4 z* O0 C

    5 |" O8 ^: X) u! Z! Y9 ]& R3 S  O您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    + X9 v5 v1 P9 g4 H) D$ a  ~
      c! y/ W! J. Q& D' M0 O0 }) n* k
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2025-10-27 04:12
  • 签到天数: 1953 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    . n/ W5 l0 F. [: [7 N! p3 q
    沉宝 发表于 2022-9-25 01:483 f$ I" d! O- ^  f: C) Z/ T" U
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    3 `; R2 x: ?3 g3 S% e+ r( T# A! o3 ?. m) v% D/ ^
    是的,兄台说的对。
    ) e0 C  s! a: Z" E' Z( d9 z& [; o" ^8 C* C% F. Q" G7 G: _: ~- A
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    6 J; i5 g" e. a& B
    ) c; h7 s; U* k6 l1 A0 Y" k雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。, o* t; n: \# \: ^$ W6 \5 z

      [' E) W6 B  i/ U& j. T比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。! c% g. q: D' r/ A
    ) I! u5 S8 x2 t% R8 [9 E
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    7 H: B9 C( c6 j0 {* Y0 P
    沉宝 发表于 2022-9-25 01:27
      Y8 @5 E- h, }5 L9 {8 b0 i你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    ! W' H! i! q9 D- e6 @. l8 E
    / Y$ j; x5 |* a* D又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。8 ~4 i. V2 [. v9 O
    3 ^! ^+ G: V) W3 `/ f8 R2 ~* z
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    , X. G9 o4 L8 X+ D又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    8 T6 n# p3 c# H( }/ e& M" I! ], L4 z
    时间差一倍的结果可以接受。
      o/ c) T5 x) s; J
    3 r1 c0 f# C8 u9 G. m' _* T你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2025-10-27 04:12
  • 签到天数: 1953 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 * p) J7 F( D( v) y
    雷达 发表于 2022-9-25 04:473 J: s! E8 ~/ X4 ], g' Q
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ' U2 S- g# @3 N7 h
    . e; Z$ |% p4 }5 z
    1 C0 }/ v* _) L( U$ i$ B- a5 `

    ' [9 J! e8 b7 {' s7 `0 t  P1 z8 i能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 9 n8 T3 n) E! G2 C& f, k. O4 j& r
    数值分析 发表于 2022-9-25 14:58/ G. Y% W9 B& v
    能不能把这个也贴上来,看看和上一个有什么不同?

      k# g' l, s: I) f, X8 y理了理思路,重新做了一个测试。/ K) [* j% r2 d6 L% }, V0 v3 b
    做了两个 vector 和 两个 float *, 都长 100000
    ; G& ]1 Z$ ^9 l. {6 t外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.( K& |0 U6 C$ @

    2 L! L/ t0 I# r2 i5 B% i( R. X内循环试了4种方法,; c! ]5 q; R2 x; S
    1. 直接调用 vector inner_product 247s , `  F% U$ i, L. S+ h4 y" w
    2. vector 循环点乘累加 237s
    ( r3 ~( L4 [9 C2 s9 w3. float * 循环点乘累加 204s6 m4 `$ B5 M3 p5 q5 ]( ~7 H
    4. 空循环 100000 次 202s' ^& h$ @( d* k

    * a8 W# M: x/ A$ W不做内循环 200s
    # ^  b* G7 [( c/ P3 b& K) I9 w2 b
    ! g/ \. L7 w$ |+ A  ~& d# ^你昨天说的对,内循环本身占比是很小的,大头在其他处理。( `5 o2 ^7 x! g) Z! i/ m( j
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。" d, t6 S3 M  t3 k& F
    ) A5 @( N/ r0 Z6 k
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    % A8 m, h$ r* `  D: h" ~: C, _* @- B$ j5 M! B
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)  ?( e4 L6 [: c

    ) f! e2 Q0 `5 T3 J2 C) Z
            std::vector < float > vec1(N);
    , `0 y8 _" e) x' D% H' U2 ~$ D        std::vector < float > vec2(N);
    . O1 w# F) h2 X- y, y        float* b1 = new float[N];0 s# H* {$ B8 E7 ?7 `1 q
            float* b2 = new float[N];
    - n1 V3 q/ p$ G, ~9 V5 {. C0 y7 I5 f% a' a4 i! r3 d
            for (int j = 0; j < 6000; j++)# a* u/ a: J% k) p& q, \
            {( k* e  J7 t- u
                    std::generate(vec1.begin(), vec1.end(), []() {
    * Z; W$ O' p. m/ x5 e; M( r                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ' Q3 q7 }- K0 @( i4 g6 ^                        });7 L, z9 r3 Y1 j8 t$ m" W

    0 G6 a5 t1 ^& D8 T! R. N9 y- q                std::generate(vec2.begin(), vec2.end(), []() {
    , d2 {: E+ ^( w0 n                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    - ?  @: C9 l4 g* I* \+ e                        });- s; [3 R% P% O1 z, F3 X* _
    - P! U4 t) v) B+ y
                    for (size_t jj = 0; jj < vec1.size(); jj++)8 W3 x+ e  l, z) c) u- R8 d
                    {/ \' r# H) S: O$ g
                            b1[jj] = vec1[jj];
    % L5 v3 Z5 U( N0 H                }' }4 q$ ]- |8 p9 x& F" M! `

    - B9 M5 C( F: B8 @- v+ U                for (size_t jj = 0; jj < vec2.size(); jj++)1 z% W5 H% G: @2 ^* b( w
                    {
    2 K7 N' b" ~7 ~/ ]                        b2[jj] = vec2[jj];$ B5 P& D% m2 o
                    }
    8 V4 N2 @/ e6 m$ A: w8 w. v  c; r0 `% y4 i! ?8 r9 {; A: n& `6 K
                    //Method - 1  N=100000 247s  
    , d) }' o0 i& b+ t- u( O                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);% C3 K; u$ y: ]4 z0 C
                                    5 p! w- ^1 a2 T1 J9 j
                    //Method - 2  N=100000  237s
    : m2 M6 [4 t1 X                /*# I" l0 Z9 e$ S# ?% a3 |
                    for (int jj = 0; jj < N ; jj++)3 l7 s0 ]- p; v2 h$ Z% m) E
                    {
    ) ]; z5 D" w' B7 \                        fresult += vec1[jj] * vec2[jj];0 p5 D7 a* q8 h7 v% z& f; w" U
                    }( i# F" _. x( n6 s
                    */$ ?' G4 y* U5 x% t. l; g
                                    0 j1 {, Z: M1 f
                    //Method - 3  N=100000 204s$ g2 Y1 i) Y% P5 O: K0 e7 x* g
                    /*; j" s% h7 S8 m& a
                    for (int jj = 0; jj < N; jj++)8 f1 b+ i2 D$ F8 f! e
                    {
    7 s7 ~* h6 C6 i" {                        fresult += b1[jj] * b2[jj];- F7 {% r+ t- C2 D5 }, C$ a/ ], Z
                    }5 U: M1 T8 C8 x" u" s
                    */
    8 M" j5 {; }4 C" g" L
    ( A: t( ?9 E, t8 T# R( y                //Method - 4   202s
      W; c# J, q. |# i6 \                /*; d# f% v4 X6 H1 P: L% N, l
                    for (int jj = 0; jj < N; jj++), C2 c, v+ s. D0 E
                    {( E! q9 p) E3 u
                            7 }  X$ _, Y6 L6 L
                    }0 r$ z' n1 X7 ?7 \( v
                    */2 N& Q9 c$ W7 _% ]! U1 t6 H( A9 b
                    //comment out all methods, N=100000  202s                ! Z( s+ V+ T* g' g
            }- L8 E5 C1 {( u$ p8 L6 ~
    4 f$ R7 q4 A8 s
            delete []b1;
    # L, `4 @. E* [" k$ w9 L        delete []b2;
    ' H1 S( n6 C% r9 I- b4 w& I* p
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?7 s! Q7 u  D9 B; i' r! W

    ; B8 X: g9 |$ A2 s7 x' d你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    0 k% `2 `$ O6 }1 [3 }2 J+ E* g$ U: v: x
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:154 N9 N/ O* M. j& b* V; K& H
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?$ W" C: d9 V* }* E. w

    7 k0 ?+ b$ g7 z" B( ?7 r你第二个试验里面的j在循环里面又重新定义 ...

    - o" Y% \7 y; j9 ^; v" @内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    " |# d! Q) G4 `. X+ I6 q2 M6 M
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    , z: Y1 p- v' k# w! P" G7 c内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    ! ^. B% _1 s* L% ~' j
    + ], K* D3 ^5 ~% u: W1 I不和它 ...

    ! f1 {+ J  x" ?
    8 k( z( J  R% d  b6 s1 ~0 w不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。. h& w$ e2 n  Q8 d, x/ J* \
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    $ c# {- l8 f  k9 K  avoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ! G( j* x* ~/ L% a# V{
    . F5 @* E5 ?6 N+ B/ e        comp temp, xtimesy;
    : b' B4 y6 a7 F* J% c. W' k
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
      {& y( i6 I! a( k内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    & W/ H* u2 a0 l( `& IVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-12-24 00:41 , Processed in 0.067301 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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