设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    , B) A( Q) Y5 q! m6 ~+ D6 K# E# y8 H) q7 s" I
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。6 n& s, ^4 ?  b$ T* C) a9 R# Z# u

    ) d) h6 A# b- _: n: z- i+ {速度优化问题真的很有意思啊。
    : L/ q! Q: @  ^0 _( U( X, D) d2 @$ N4 L& `
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?; x6 {; v8 _; Z1 }2 J9 A. c4 f
    把代码贴上来看看?
    1 I! e5 w! J- Z, j% V/ W. p% d9 r: W( _+ v' u1 ^% T
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    5 e6 K9 m8 ^. i  t, L9 F% u4 F
    数值分析 发表于 2022-9-24 23:04
    1 n" D0 H. V. N% f  H4 e. V; r拉下来?拉多少?
    # |0 [$ c; o. i/ u# }9 C5 x! O/ a把代码贴上来看看?

    + h0 ~* Q5 o) q( [4 A6 M' }9 `# M
    % j4 J; G9 q; j$ b; q( `void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    - q) o: d* j9 y: e/ G' C- V{: G) G/ i6 g# @/ W( n
            comp temp, xtimesy;
    2 z6 Q6 H  J2 r1 `, X8 @        xtimesy.re = 0;7 S, P" s3 F( P% }- I
            xtimesy.im = 0;) P, {7 k. G8 D: e$ a4 l
            int j0 = lenB - 1;1 F( }) l6 E- C8 k% s
            int    i, j, i1, reali;
    - J! I% L+ ?; U" }4 G1 X$ x$ p5 p( `6 H        if (lenA % 2 == 1)
    . h$ ]: c3 O+ ~                reali = lenA + 1;! \% g9 v- l/ h2 a# E, h6 l/ k
            else  V0 x! V  [/ x, K$ ]' _  k/ v: ^
                    reali = lenA;: I$ g* M( }1 m1 u9 o
            reali /= 2;. A9 l. J; D+ l1 U9 m. v; I

    : Q4 f, |6 y7 g, l/ k! P  T        int nconv = reali + lenB;* Y& [" F) V! v8 ]* A+ g5 l0 U
            //#pragma omp parallel for
    . v5 A9 V2 y, T5 h        for (i = reali; i < nconv; i++)
    ) i' S* }4 P  x4 E; N6 j        {3 o, T" r/ ]+ Y1 h# }6 v5 n5 e
                    temp.re = 0;
    7 P. S! J8 Q1 V5 n0 w- J/ m                temp.im = 0;
    4 q; Z% u; {4 J, o$ @6 l, k                i1 = i;
    1 b( w: s+ J& G                for (j = j0; j >= 0; j--)$ b! R$ U- G1 x1 d
                    {
    - O% i% T. _! c! w' q! D                        /* floating date operation */
    ' D4 u6 I6 q! H# @                }
    ( @, u( P1 h, L
            }" O; N6 ]5 m8 r/ s5 T9 q1 `# ^0 H: H
    }/ ]+ u# e) [: \: X
    ; U$ p7 y# c7 P
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    & b. |! ~/ j) k) ?
    * r/ w/ r4 X9 A红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    5 C$ c5 c# O# r- ^# o+ C0 G+ H+ [现在call xcorr 100次,耗时78s.
    ( C$ G& R% w4 U5 `' F* k7 c- `0 P- g, T7 F
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 1 q( Z; s; u7 `- V- d* Q
    0 O' f1 V9 s8 [4 `
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33- H$ S2 p! ~. e4 j
    Maybe Debug mode?
    / w7 S$ _- t  ]7 y/ r$ e
    ) Y6 y4 i/ R9 X& q* |" O- E
    不应该,看我上面的回复。( x8 B6 v. u, U/ q0 A' [% I8 \7 `

    " T4 \. F$ }( p' p/ h' X% E我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 : @7 Q* F( X4 o6 B, W5 t
    雷达 发表于 2022-9-24 23:54* a) n) Z' m- Y! X, ~( D
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)' Z6 A! X' G/ G$ Q; I2 G
    {
    ; P2 ~1 F) [9 ^4 Z4 \        comp temp, xtimesy;

    6 z! w" W, r+ \8 S+ X: E: U( R
      J4 ^% B" h6 I3 c: @# \: @4 B3 [9 }0 C这个不是这么比的吧。。。. M4 N; N  j; e; b5 F( ~

    $ C  y/ j  @8 v5 v$ I您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    / D* e5 Y# p* x; |' E% P9 G, R/ l/ {7 m- X
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    ( ^. i1 }7 _. k3 |; C
    数值分析 发表于 2022-9-25 00:20$ V8 [5 N2 K  ~0 t& h' ~
    这个不是这么比的吧。。。$ t; [# d2 m  q9 g! H. q

    & D4 a/ o, X6 ?/ z0 I您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    0 {/ _: N7 G- w* v, U+ X, b
    8 r: A) z0 Y9 l3 q& `' p- W5 V有道理。
    ) X" a1 @- c' t+ a  ]4 Y所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。& b5 N6 U3 Y! P$ N, e: h
    : |$ Y) O3 L6 x
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    : A% R, [  C0 \2 ]有道理。
    & M* W$ |" P: u* c# a" W所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    2 A2 z% j# [3 p9 j/ w你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多1 ]" F+ k) Z+ L
    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
    # i9 L; X8 ~- z% ]. X这个不是这么比的吧。。。
    " D/ Q  I9 z2 }( m  S. E8 a. u4 t: U8 b& g5 S( u9 O: O2 J" q9 b* ^) `" `
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    , d: d$ o% O0 D0 O: a
    8 `7 i+ K" R) N8 i/ A6 c" ~7 p
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    ) n9 C' {2 w) P+ l. M; F2 }
    沉宝 发表于 2022-9-25 01:48
    4 o  r, N: [) }; d3 O' u% P  O现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    2 `$ l1 e/ h% b! m# Q

    $ i/ d- T! b" a" y# |# O是的,兄台说的对。' M) r0 T* I+ }# U; ^
    6 T/ T# [3 p7 i; |. s$ `* I4 o# ~
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。4 y: j" m5 s8 _

    + B# s" }6 A* o: a& c雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。: c3 f, w8 `) R$ D1 J
    3 _! Z* K( S8 M# A1 w3 h* Z
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ; V/ s  u4 }4 b4 o6 C5 n5 b" }- J3 Z9 _, h
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 , I4 Q) P$ m2 d0 J
    沉宝 发表于 2022-9-25 01:273 n/ }0 S4 e( q. d
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    6 T4 B  {* E5 P  V" c
    . j$ n( `0 q3 p0 d- M6 L又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。' u# {- q4 s6 V# y

    . I& i) U  {2 P4 O: [% l' F; b) S$ Y我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    ' \: }8 T0 W7 g( ]1 S9 h又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    , @9 U3 s- H' r时间差一倍的结果可以接受。
    9 h7 Q$ g& \! W) \
    . @4 f# q- ~( x你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 3 S! }+ I" D! F# _2 N
    雷达 发表于 2022-9-25 04:476 k* F) C/ G! f! Y9 e
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
      X4 c8 y# o, L( W9 h
    0 f: Q; @" l4 l8 \

    ' h& B. `/ w. q4 z6 T  f; L  C9 S- s/ F, @$ [) n
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 : R' G5 }' V6 Q
    数值分析 发表于 2022-9-25 14:58
    - M% J7 J0 o+ u# I. S: U. n能不能把这个也贴上来,看看和上一个有什么不同?
    9 F6 S0 M' i! g' c0 D
    理了理思路,重新做了一个测试。
    * |# e" c2 c% g8 |" G; j0 W做了两个 vector 和 两个 float *, 都长 100000& `# Y7 r" x4 m0 r" A# R" g6 ?
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    * C/ o; J' K4 Q0 [
    ! _& F) R# p9 s内循环试了4种方法,0 F, t! [; F0 I% P+ H5 f4 c
    1. 直接调用 vector inner_product 247s ; S! e( G; Q" |
    2. vector 循环点乘累加 237s
    , d4 M9 A4 f2 s$ q6 X6 Q# m3. float * 循环点乘累加 204s4 w( Q2 n7 L5 u7 s# h
    4. 空循环 100000 次 202s
    * j# f( G2 `+ l  L( y- p3 Y6 C; _, i2 ~# m8 U4 l
    不做内循环 200s
    ) e6 v+ J# P7 [; E& K7 c% M9 F. ~& y# l
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。# E8 z' ]2 Y' C$ j: v: W; I9 e
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。8 a# v) ^' u0 n" t# J
    : e5 y$ O$ H( C8 r  q# R* M
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    2 [) K: c2 w& ?1 u% E( i
    : W4 }5 ^# _" G* |, \(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
      `3 ]6 k9 H+ c2 o
    3 _/ }0 z0 a! B2 X& I
            std::vector < float > vec1(N);1 l  f, ~" K& i' O$ d+ I* M% X
            std::vector < float > vec2(N);
    3 X! g" F# x8 y2 c# w8 K. c        float* b1 = new float[N];( i' c! K2 e4 z9 M; s
            float* b2 = new float[N];
    0 t1 j; N* i+ B2 O
    " r' I7 O# o7 d        for (int j = 0; j < 6000; j++)
    " v, {3 s  y' b3 e        {
    ( h* y! [9 t- i; ?- e                std::generate(vec1.begin(), vec1.end(), []() {
    5 u$ a' X0 V/ e7 C8 t                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    " i$ A9 [$ ^; P/ P3 v                        });  L/ ?: v% Y) U9 ^8 }! i: ^

    - {4 _7 M" W4 o8 G5 J! M* r4 o                std::generate(vec2.begin(), vec2.end(), []() {0 G2 F% ]' X+ x- }9 I
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;1 C" z$ J  Q" e& D  K4 K: b
                            });+ k5 M2 s) m( d: ]2 |

    3 m' r) X" I( ~0 _1 N7 `                for (size_t jj = 0; jj < vec1.size(); jj++)7 A- m1 Y  G4 `$ v: c, P% m6 I* r
                    {0 a( f/ X7 A2 S3 l) g+ D
                            b1[jj] = vec1[jj];
    9 k& h5 b4 l( x# @2 v- d, N) l                }
    . A* c6 h3 [; _& o: @
    6 b2 y4 t# G" y6 A& {                for (size_t jj = 0; jj < vec2.size(); jj++)2 m4 v9 p- l6 V
                    {
    $ @: \; W7 ]+ R+ P                        b2[jj] = vec2[jj];; D- a" l' F* ~/ n1 m4 J- d
                    }
    % A. s( y  P9 ?7 j9 L( j9 u6 V, ?; F
                    //Method - 1  N=100000 247s  
    - k/ _6 I4 G9 A3 w' Q# y                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);1 z1 U+ f5 k4 B  W; x
                                    5 t7 Y8 q! F6 m/ I. E
                    //Method - 2  N=100000  237s
    ) ?1 I9 y+ P( B5 X3 C+ s                /*; z8 S$ y6 `% U, m) }
                    for (int jj = 0; jj < N ; jj++)
    " \1 ~9 q/ {# g8 Z$ G  F' M                {. T/ l4 D4 a- ~( Q1 B8 Y5 j
                            fresult += vec1[jj] * vec2[jj];
    + k/ a  `0 e0 L5 s: }                }8 w7 F" F! T4 M$ u! m1 X
                    */% `4 o/ s! r9 |5 k+ f
                                    # M0 h. }8 S/ e' b8 ~4 w" W
                    //Method - 3  N=100000 204s3 D, X5 j* C$ i3 V5 R, ~! G
                    /*
    ; y8 g7 M" e+ n: _7 s                for (int jj = 0; jj < N; jj++); f- y4 a- s4 O% ]
                    {6 Z1 K; R' I* Y3 q9 R
                            fresult += b1[jj] * b2[jj];3 V' Y8 O3 Q( p! |2 x. w
                    }
    3 m8 v9 e9 i) n' i' D, i; E                */$ w! z1 K8 \7 [) W, I- _, R3 j

      m( `( d$ u- D1 a: p                //Method - 4   202s- q1 O, s# P$ d2 z$ M
                    /*( ~& C" G% G( x4 ~9 u* N% |
                    for (int jj = 0; jj < N; jj++)3 b" S: D; q& r2 W% I7 [! S
                    {
    2 g% `2 o3 ?# I* w  W% o                        
    ; j) G5 T& y7 d+ X3 i9 M8 X                }
    9 E# g& x7 K4 M                */* T  A7 Z! f0 ^2 t6 Q/ A
                    //comment out all methods, N=100000  202s               
    8 W( S/ [$ E; z% }8 n        }4 Y* A5 ]7 X3 k, D2 E  F
    1 F) C: `: ^: |6 g
            delete []b1;
    9 z; O( j% R! ?        delete []b2;

    5 X, y2 {' L+ z' q9 _" G
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    2 g3 }  g; y+ Y) [3 l9 E( l6 x1 t. W# o# ^  d# C
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    - \+ o) v# }7 N9 l/ }. a; Z# y
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:150 `# y- b% _6 D( }. w  d( L
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    : }' h/ m0 z2 |6 x3 T
    , j! O) q& P1 h  }0 ]4 J你第二个试验里面的j在循环里面又重新定义 ...
    ; ~4 {$ }2 |0 P* c4 h0 y
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL! f# q' h2 _% Y6 F, R4 b; M4 J) ~
    : I( Z2 m; ^) x4 `) B
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    + h- X1 h4 W  C4 _0 Z内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL% ?" W  s4 Z: ?4 {' b7 q; a
    3 p% A) p. N. g( `7 A; D. a$ ~0 E
    不和它 ...

    ; X  H9 H: p4 I# F. a; S1 r' Z% \- |: n+ @! d# L
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。1 K- o' _3 l! Z' P! s
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    6 V! a" |9 J6 W( Z$ `; ?void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    5 P8 k7 M, j9 M' f{
    % K: n% i% I% s) V        comp temp, xtimesy;

    8 ]2 l0 Z2 N2 a( M这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。" v7 }3 V/ U0 W: q+ L( ]
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    & |+ {& L% I3 ]" c6 U, c5 ~VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-2-19 07:00 , Processed in 0.054158 second(s), 20 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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