设为首页收藏本站

爱吱声

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

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

[复制链接]
  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?& _  ]2 d, }' a8 {
    # v( ]$ ?* o6 r; T0 }6 u
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    ! a9 g2 D. C4 w
    0 B& S: ~3 Q+ {速度优化问题真的很有意思啊。
    , s9 L! `- Q8 C4 y: ]3 m) e. [
    7 }& @1 j; G" Z" x: m6 P  u欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    昨天 00:53
  • 签到天数: 1713 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?; k# ?- B/ {+ V$ n8 h
    把代码贴上来看看?
    9 L; }3 C4 P+ z0 O0 ^1 ]9 H. ?0 Z, o0 |6 s; {, x! `8 [+ P
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    ; ?+ b3 _& I0 A, W  N
    数值分析 发表于 2022-9-24 23:04
    * r0 Z% d* F& V( W8 x1 z拉下来?拉多少?
    ; _3 d7 W2 K2 }1 T3 ?; P2 r0 P把代码贴上来看看?

    7 g+ {8 r9 e; N& u* X5 d4 N) o2 a# k- K+ S2 V
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    + y2 B$ _: C( C3 z: x( B{! y, d0 ?+ }! \4 D0 ?; i
            comp temp, xtimesy;8 ?6 k" |4 w- U
            xtimesy.re = 0;
    ; }5 d1 w2 _8 y+ C5 a5 p# \        xtimesy.im = 0;
    8 K, S$ h6 y5 \* E# @        int j0 = lenB - 1;
    * I) R' H% [& g* r7 x3 o( {+ {        int    i, j, i1, reali;
    0 c% J; o. y6 q4 o        if (lenA % 2 == 1); Z% P9 ^( P# |1 k  B0 b/ M/ h
                    reali = lenA + 1;; Z; G/ J' h) W. m7 ]% C( m1 c
            else! x/ J; ^4 M; p$ _
                    reali = lenA;. `; m4 F6 u; f8 g' g+ x8 k  x
            reali /= 2;6 b  n& I3 ^0 |) A9 K

      Q+ l7 c* ?* u- l; c4 A        int nconv = reali + lenB;8 x( s) ~9 n' y2 k! i9 p) R
            //#pragma omp parallel for3 [( D+ W, M( t
            for (i = reali; i < nconv; i++)& R, k/ |4 D1 X- P( I$ O  \5 d  t
            {; R" M9 E4 e$ d' E- {
                    temp.re = 0;
    8 E# t/ C2 Z( v5 t8 ]                temp.im = 0;% n  a3 B+ j6 `, |) u) ~
                    i1 = i;: r+ \' L0 m1 U3 |8 T
                    for (j = j0; j >= 0; j--)
    % A! Z6 U2 y: W; k% U3 l% z$ X                {
    / ?3 P3 X( a5 d' b: |! L                        /* floating date operation */, D- `8 k2 V+ ~6 Y. ]3 W2 W% o
                    }

    7 G6 L9 \/ g; ?% u  D. f6 E        }
      x2 h, R6 S  r3 l1 f! ^2 V}
    / {% [6 J% m+ e8 e  A( u
    ; y% Q* i' ]3 a- y; axcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样5 _' S7 v- U. Z# C) A
    ! Z! K* q2 m/ \$ n0 @. ]. p
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    9 M+ x' C  d  ]( _现在call xcorr 100次,耗时78s.
    ; a) X5 l* h3 J- V5 X
    + r9 V+ D* H2 }+ H7 }4 O; z7 I6 ]) c如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    : y5 w" |+ p, G6 [2 ~" Z, \6 X8 C- F+ Z+ j  ^% }
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33) s1 O" G" R* N
    Maybe Debug mode?

    / f. Y: J$ k( Y; e# x; g* X$ f* P- L  l+ o0 x; F  p
    不应该,看我上面的回复。0 D) u7 S  I* V) m$ J

    ) [4 m1 L4 c$ S* _3 {7 V0 A# T我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 00:53
  • 签到天数: 1713 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    # \" _, G* ]0 O* p1 n
    雷达 发表于 2022-9-24 23:54% b% I* q% t) E8 S- i0 R3 e
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)9 f+ Y6 M2 q8 V+ t  x8 N# W
    {
    * R/ i3 M% d$ u  T" {        comp temp, xtimesy;

    3 @7 K; E# j5 i9 A
    : y% r& A2 w: U5 s/ s这个不是这么比的吧。。。
    4 e+ z( V& W) r% h  c, u! u( v! f" t
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。$ ~' m8 [+ W  S6 @
    2 p1 T" V/ z0 [2 b6 J
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    $ e4 p% S3 F, O+ {
    数值分析 发表于 2022-9-25 00:20/ d0 [) c4 p" |: g8 |1 g
    这个不是这么比的吧。。。
    8 [3 G& ~! U: @" c; ^% h  z* E( q9 t3 _! y" j; z  R' V7 l
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    " ~. o" \& i, k% o

    + V/ p5 }) x! r7 {) J( X! F0 P有道理。- r4 m: U) N; W6 A. ^6 K
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    - A( B) f  f9 g0 a
    7 O; _: [- S! V/ i6 B# W) G我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46- D; H: B% t* X) A0 g
    有道理。* p+ f3 X4 h8 I/ T" o( Z3 N
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    3 H7 o( R6 e2 e  C0 L* Z' B. _你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多( r6 Q( Z3 A0 J3 Q$ w" l" I
    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/ D; A+ {  v, K5 W; p. ^3 [
    这个不是这么比的吧。。。0 W+ @% b. x. l8 B8 l6 ?

    3 F; _5 o( i9 r: ~3 D& L您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    ! r* M( K- N: E6 u$ I9 M
    - z2 u5 x6 M4 U# k7 j! x4 e
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 00:53
  • 签到天数: 1713 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 , a+ d$ B! s2 I2 e% N5 T5 X1 a
    沉宝 发表于 2022-9-25 01:48
    8 V2 J3 Z$ w) m5 c现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    * N3 R& l, q. D% K8 C' }. c) v  W3 l: _% j+ f) r$ _2 r
    是的,兄台说的对。9 s. @7 n( a2 \3 [2 n; O4 n. \
    * r# M! T7 x0 R! [
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。+ n4 \) M& Z4 \2 E7 j6 i5 [) v% t
    5 ], m( E1 H2 G" B7 _. Z
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    % U$ ]) r/ J0 c$ v+ m0 k$ H9 ]9 z) C/ ^/ K3 H  N+ Z5 \
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。6 o5 n2 {: `; [0 i" o! F, i# V
    3 E9 a5 Z7 v9 f# _1 j7 k
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 2 W; h8 m9 w- G/ T0 |9 T
    沉宝 发表于 2022-9-25 01:275 ^# S' }3 ?4 ^( Z$ @- j" l9 n3 t
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    3 h6 c2 Z8 @( R' F5 t3 l6 t
    1 F$ V" L# m, \7 T/ z9 j+ o又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。0 Z. z4 k. }$ e9 X% c

    ; s( J% C! k' ~+ Z# J我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47; M+ o1 S8 v0 s- s
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    + C) j8 v, x) k% _
    时间差一倍的结果可以接受。
    . }4 a. Y$ l. R: d- x% G/ d
    ; E6 ~: }- E, t0 e' a& W9 t你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 00:53
  • 签到天数: 1713 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 * `$ v4 u: h5 S9 K
    雷达 发表于 2022-9-25 04:47( u+ u0 Q* I9 r0 @, |; Q
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    * g3 c2 U- A4 D* |1 X
    1 B- u# A- T) T, b
    ' Z2 u/ Z& o& t4 }7 L

    8 E' o+ p1 Y& }4 v/ Z能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 " D4 F/ p( ]3 q" v. N; Z
    数值分析 发表于 2022-9-25 14:58; W9 \8 ?" l5 b( {& y3 m. L8 b
    能不能把这个也贴上来,看看和上一个有什么不同?

    $ D7 G' [% \2 m: p4 d& D4 h理了理思路,重新做了一个测试。, c) b* ?7 ^& y9 M1 |- k/ Z
    做了两个 vector 和 两个 float *, 都长 100000
    5 [0 x. N  i7 }8 Z/ }外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    ! N( n0 g! i+ f& S0 c' R+ R
    4 B7 w+ D1 Z3 u) ]( j. A  v1 {4 V: J内循环试了4种方法,& x. v" l- g' J" i7 j/ G  M
    1. 直接调用 vector inner_product 247s   F2 p( Q( [3 a) D  z! j
    2. vector 循环点乘累加 237s3 o1 E- q$ Z: i5 L) }5 B
    3. float * 循环点乘累加 204s
    4 J, r' T. s$ W6 K. t- J" `4. 空循环 100000 次 202s9 D! o- k/ m3 j9 S( v

    " z" [7 Q6 A" k/ u! K( y! W不做内循环 200s- x0 V  }& @* ?  z
    1 _5 X; [: q; M7 }: ^
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。, u# Y" B, ~5 H- Z
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    1 |4 ?9 e; _+ c, {, B
    * N9 f/ Y$ B: w3 p6 c8 I& f! e至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)! W+ t# b5 k$ O$ j" F
    + f' g& v8 r- b; a3 M
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)6 l/ o. ^9 X! y9 K7 T7 t

    9 f+ c3 D  x' e9 p0 l! c. _
            std::vector < float > vec1(N);4 ?& y; R8 g4 Z! S: E% f$ s
            std::vector < float > vec2(N);( d# t2 p- F$ P+ ]( c
            float* b1 = new float[N];( C7 A! ^$ i2 ~0 _5 L- t
            float* b2 = new float[N];" C) G$ w" w/ L) e' t
    . e/ `" {" G3 X9 U
            for (int j = 0; j < 6000; j++)
    4 r4 U  w9 z$ F9 Y) ~        {# Y9 U' b& w$ _- T. U' I
                    std::generate(vec1.begin(), vec1.end(), []() {& W/ ^* g, L: F' P0 x+ X% E
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;1 C3 \; M, d- i, E
                            });
      l" e: d# C6 \
      Q. W( J. m" Z& q& c8 v' F+ c                std::generate(vec2.begin(), vec2.end(), []() {5 r" D6 J, O, ^
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
      x! g* z3 _) }/ [+ T                        });
    , v; I. a$ L$ a+ d3 A/ n
    8 W9 [  [9 ~% [% }                for (size_t jj = 0; jj < vec1.size(); jj++)* M' S( C! o+ I! {  M* r! N3 R8 ]- Z
                    {( Y) D, Q$ \! W. G, X  p" p
                            b1[jj] = vec1[jj];
    ) }' j1 ]$ B+ g9 r+ a                }
    7 C, I- [8 N6 c  K/ s5 L- Y2 s: ?% c) z8 ~% ]2 x- l, ]
                    for (size_t jj = 0; jj < vec2.size(); jj++)1 x. N' d1 _7 j* |) u
                    {1 P/ B3 Z5 [9 Z+ c3 a) x% p% F
                            b2[jj] = vec2[jj];
    + b$ u5 \' C8 W2 K: ^! r                }( K5 b9 t5 z1 K# z0 b% {
    " j: i5 L" G2 k. n- x. H
                    //Method - 1  N=100000 247s  - [2 _) a% ]0 [
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
      \- A+ i3 V- R& w                                5 ~& ]  X' O7 R4 Y* x
                    //Method - 2  N=100000  237s
    , q% I& V6 C0 I2 K( A9 x                /*
    ) Z0 T8 d) P* h( x. w                for (int jj = 0; jj < N ; jj++)
    1 S4 D& y, R7 g8 M! _4 v+ A% E                {
    0 G. R4 E3 Z( ?% e                        fresult += vec1[jj] * vec2[jj];
    9 M# k3 D% A3 v- t2 P1 s2 x6 _                }/ Y8 \" s" r, W# \# i2 R6 x' u  D( l
                    */
    * R- C+ Y, n7 }: h  _# D                                # h! l; b* R$ {# |* L# ~, S# a* l
                    //Method - 3  N=100000 204s& q& z* D+ K; D/ X: p: A1 D; R
                    /*
    # [6 l' ~% ^8 R, n                for (int jj = 0; jj < N; jj++)
    ' [, d3 j  t* e0 e                {
    ) I, R" ^( ~  |1 ~                        fresult += b1[jj] * b2[jj];; J* J2 f4 B5 S) `
                    }9 n% J* W, J1 I% ~
                    */; Z  b' H$ Z# W8 R8 {5 F2 |

    9 M, k( c& K# d                //Method - 4   202s% B; d) A5 S, ?5 Q) S, ?
                    /*4 G. }8 P; c5 n/ O- d7 J4 o
                    for (int jj = 0; jj < N; jj++)
    9 t7 B: x0 K) {2 f, o                {
    - \8 f1 C+ X9 J                        ! L' T1 ^( M: S. a
                    }( B) U3 Z7 ?; o/ o/ e# \
                    */! J% \& v% C/ i- Y
                    //comment out all methods, N=100000  202s               
    & T, A' ?0 o& ], O0 ~5 ^        }
    + l; P$ M( L# C! E
    ! ]0 m" u2 Z+ F8 G        delete []b1;- {, Z( a4 X5 K: C
            delete []b2;
    3 p7 I) U+ A" V, G9 r' ~% a3 u
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?0 l! l0 @3 w6 j/ z/ `. S& a0 F

    3 K6 E3 u6 ~2 P+ Q你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?4 g0 p* L8 M6 Z
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-9-2 21:30
  • 签到天数: 1181 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:156 a4 L: f$ z) c$ P+ }9 c" N5 P
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    & L6 `9 @$ ?8 N  r% Y# D) Y( D& C; r9 B
    你第二个试验里面的j在循环里面又重新定义 ...
    ' W% _# k3 q9 H, ?5 q
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    ( i' E  Q# p. N2 K8 c; |5 h  r3 ?) L0 B- E' z' X
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    % C5 a* r2 n' m内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    7 o3 y8 F5 ~( H) X
    7 }) w  ?, k: [# a不和它 ...

    ; [; c- {- ^0 D& y, M! q1 j  a. p- K
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。8 e% C# ~. P, Y, p. O
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54# }: E, @8 ]2 l8 F% Z
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)% L' A) T, @1 k9 h# r' `5 B! q
    {) A; a5 e* ]9 o( |; m# y
            comp temp, xtimesy;
    ! c8 p* m" m3 W
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    * e+ R( z" S: S9 A5 m2 v内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    , I' Z. e3 ?! VVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2024-11-11 04:19 , Processed in 0.048275 second(s), 25 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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