设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?: X( k6 v+ ?6 `
    : b% S! ?2 E( H9 j! o
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    & x# h) {6 ?9 r$ o( k& d4 U4 y0 P. g& D) o  o8 F& C
    速度优化问题真的很有意思啊。
    & ?, y- j' t6 l; m( ]8 V; F" {+ }6 B
    9 x" v) l8 V; ]9 d欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?: m/ G! p7 \% ]( |
    把代码贴上来看看?
    , u& U2 ^/ D2 H8 O$ n' a, n3 M  T& L* B: |0 U
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 9 G; I* v- |9 @1 m+ _9 r+ j3 \
    数值分析 发表于 2022-9-24 23:04
    , v3 ?* s4 E/ x- D, }( g拉下来?拉多少?
    3 ]6 c; C) D( O把代码贴上来看看?
    , F/ i$ [  H# W3 a

    $ I5 q0 P( G" m5 Z& P% l7 P, n) mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB), H( m0 p: x+ E4 Y+ k$ \- T
    {
    ) C: N% A' o/ O4 v% D- o        comp temp, xtimesy;" V5 z- X# X; X' i& s. H- S1 k4 W
            xtimesy.re = 0;0 w; @) p& Y( x$ E
            xtimesy.im = 0;# A+ s* P& O  p* j7 F" h" A6 v
            int j0 = lenB - 1;
    3 r( h  f* ?8 R5 S        int    i, j, i1, reali;
    2 `6 ^* N+ p7 |        if (lenA % 2 == 1)
    . g7 L, q! i( p8 k: R. i                reali = lenA + 1;' J6 I+ \* j9 W. @9 J8 {
            else
    * W& H% W2 g* ]/ [- z7 k  G                reali = lenA;/ _) V( d* C9 G: ~, t& `. K' ]; h& j
            reali /= 2;+ E* T9 N( M: N4 D: v/ r6 C
    9 N/ {1 l- l- v
            int nconv = reali + lenB;5 L' L& u  H/ i, K: w" Y$ v
            //#pragma omp parallel for. V; M- X+ u, K0 W+ {
            for (i = reali; i < nconv; i++)( }' k; N* Z" {6 g8 K
            {* K! N; W; x$ z& d
                    temp.re = 0;* P5 ?5 l* U# h# ^( U0 \
                    temp.im = 0;
    0 K' Q- |0 d3 K9 p! G                i1 = i;
    , R% d  H" _, V& Z                for (j = j0; j >= 0; j--)9 x% K  E2 Z8 c2 n9 w5 H
                    {0 S: z0 F5 F: c$ R5 _& X( `  g9 F
                            /* floating date operation */6 ^9 X1 b& z: p0 \$ X3 z
                    }

    3 p; @8 o' y5 e- Y) q" L5 O+ k        }
    7 H+ @; A' a( s. x& v}! B, M) L, z/ e9 v5 }
    3 Y% s* R7 C( [# d5 v9 N
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样% d: A: X+ M( l( h6 N' w
    3 m7 q. ?  ^- w) y0 J) R; h4 r
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。8 N* p: g$ k6 U* t) q
    现在call xcorr 100次,耗时78s.
    ! X+ c" }$ `$ q3 w9 Q9 b& N
      j% K# Y* V$ |# i如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. : D; h6 t2 A) I# {6 Y7 e' n

    ) C7 {( L) }) y; q. G
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33. s0 ?0 j2 b' S" u
    Maybe Debug mode?

      C) R1 W% d, C9 s: @" O9 l( f8 ~+ X0 `1 t+ K# Q1 @4 U, f
    不应该,看我上面的回复。. H5 I: z2 w# T. Q6 d" z

    ) l2 G# U/ b  C- k& }2 {4 j7 E我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    1 C5 f+ M- c+ d  R' {0 s1 {+ G
    雷达 发表于 2022-9-24 23:54# b/ `4 m+ n' B' u- Z
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 t! k% r* ?8 R+ j) ]# A
    {4 _0 O0 Z2 m1 Y/ O
            comp temp, xtimesy;

    7 ^2 E! k5 e$ r. f- l: c
    3 J5 P8 ?; Z! n这个不是这么比的吧。。。1 l# ?9 {1 g$ D$ V# `! H
    # t3 R: h( Z+ g
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    ) z4 S4 _( T/ m% X% P  }9 [
      H, o1 g, g0 e, y, }4 I# f而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 ; L1 B7 G0 Z6 r0 @! s  {6 ~
    数值分析 发表于 2022-9-25 00:20
    3 a% C7 Q( ^3 U9 u/ h) C3 j/ n这个不是这么比的吧。。。. Z% s$ e- y$ H. A" ?
    2 I; D# b4 `) I
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ' B+ `3 o- }2 U
    + s( G- N1 p+ {8 e有道理。
    - Q* ~0 r, B( v9 n$ i所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。: x* q8 s& U( g# [; k! W, |

    . t' i. j8 G! H1 M我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46- |- f6 S' |1 v$ \5 d+ v" G
    有道理。
    ) x' w" `, t* P; u" t所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    8 `- ~) F% z' g# j! m% h& h) z  o你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    " i  ]9 J5 j9 l4 b( M" R% s  a: AWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    8 d+ c+ p8 F4 e! Q7 Z0 B+ H4 z9 p这个不是这么比的吧。。。8 O. V2 N" g5 v" u' E
    + k% x) C+ X8 I, A' Z
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    1 x/ @, Z! N6 r" M

    4 b  k# G5 C. I6 q0 f# P现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 7 v: P/ m# P7 j8 ^: Q
    沉宝 发表于 2022-9-25 01:48. P1 `8 N' N! T( y( u) i; f3 m$ z
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    3 F, Y& n. K3 l) m2 D5 F2 Q
    9 T4 M  d2 u5 G8 x3 i" z! K" C
    是的,兄台说的对。: V$ B' G7 v( e# F% C
    / D2 E4 i2 w+ t! [
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
      p3 \0 C4 O* b7 c4 l6 m; z: }6 ~
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。: _6 C' X) H" z$ o) E( z
    5 |  I$ N2 D) r$ k. P
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。% v8 N1 s. k' d9 Z; c

    9 E2 h, Z  e( J当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 ! G, z( z, k! C) t
    沉宝 发表于 2022-9-25 01:27
    6 f9 @3 S5 H) O1 }9 b你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    3 Y. w# j* a& X# ~2 [

    5 n& \8 m' P5 o又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。, f2 @, y& b, |# O4 x! t+ r
    ' [- ~# F& C# J8 I& K  e
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    1 u7 N. f( x( M% @- O又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
      t& `4 c+ L/ R/ K  I3 D
    时间差一倍的结果可以接受。
    7 M3 _/ z- t0 j" \& r0 b3 ]; `/ R# S& e* f# ^  L8 P7 @) }  a8 H, A
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    $ S+ v  U! _. u0 W& H" C
    雷达 发表于 2022-9-25 04:471 y/ z/ i, u! X9 X5 E1 ]) \
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ) c/ t+ Q8 Y$ ~. e5 E* ?6 _
    % q, r5 h" i( i( }  J
    0 S2 E5 @: a3 U# c2 ^) K7 J7 y
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    1 Q0 N4 A7 k9 a$ q5 R
    数值分析 发表于 2022-9-25 14:58/ B; Q" k' X+ }& _. ?' c6 ?
    能不能把这个也贴上来,看看和上一个有什么不同?
    & N! d$ U$ a6 C3 R4 j
    理了理思路,重新做了一个测试。
    0 @3 [$ m9 Q2 v6 s做了两个 vector 和 两个 float *, 都长 100000. q( l5 g% ~3 R
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.3 ]& E! ]9 A& `, X' G

    7 F7 e1 N3 U4 F) G5 s- {$ t" O) l+ B# N内循环试了4种方法,
      C$ O- k9 G8 [5 C1. 直接调用 vector inner_product 247s
    & t5 g  [; G, Q0 x7 f/ _2. vector 循环点乘累加 237s
    . V( {3 a* W1 K6 y: S! L6 @3. float * 循环点乘累加 204s% L$ z) v% l, X, P
    4. 空循环 100000 次 202s3 K; l8 i/ x5 M) s

    3 k) S" g( E8 b. A, J; M不做内循环 200s
    3 X& }5 N1 j1 Q- g( ]
    ( c+ }2 n0 e7 ]$ S+ t  F. W( V" ?你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    $ l2 \; Y( `9 H- l4 k0 p4 T# ]6 O另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    ; v: v" L. ]2 s5 D3 w' J; \) @5 ^. Y1 m+ ^9 q4 x9 K1 p
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)9 x4 Y0 Y$ ~5 E. o8 B4 {4 B& w

    , D& _0 z# ]$ q2 F( |/ b- u(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
      ]' J. ]  p  _, E# O. G: B/ z" z2 s) A
            std::vector < float > vec1(N);
    ; N4 a5 y# i4 l! e        std::vector < float > vec2(N);
    5 I- N: k1 o3 K/ s+ ]. b9 P        float* b1 = new float[N];
    - F) ]% W5 \' X, g        float* b2 = new float[N];
    8 Q4 b- O# k+ U* h$ R
    ) B- b0 r1 D# X        for (int j = 0; j < 6000; j++)
    & e/ z: U+ ^# n7 G( b. H8 ^        {$ E: v/ Y5 K5 m( R$ s
                    std::generate(vec1.begin(), vec1.end(), []() {
    , y% D1 k0 W  u3 K4 b  t# x                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;% `. t; A- l! Z1 Y/ }
                            });
    4 a% G+ d% b1 Y, I5 m% b% ?  H3 a/ e1 ], J" p
                    std::generate(vec2.begin(), vec2.end(), []() {. G. c( o6 u( {+ p( B8 W
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;9 ]  x) L1 Y- {3 @% g% u
                            });
    , I# V- C- b& M% m7 K
    2 c" s1 q1 A0 Z# j# d1 a0 H                for (size_t jj = 0; jj < vec1.size(); jj++)
    ( J/ [) A! Z4 q, ~3 r6 H4 E: X+ p; H                {2 b( e. S/ R) z( z5 U
                            b1[jj] = vec1[jj];& u. }7 G7 d! F! z; b. O* I
                    }
    + S* S" b9 H& e2 a+ T( b
    : x3 e% Z/ y8 h  U4 O                for (size_t jj = 0; jj < vec2.size(); jj++)4 A  G  p. N' I  c! X7 O
                    {
      @: Y" s9 n( J; w: A- ?                        b2[jj] = vec2[jj];
    / F' L$ q3 y' w; L                }
    8 k( P- b8 [" G+ R8 B) s; I) \& u2 V4 [" Q4 r) S) r
                    //Method - 1  N=100000 247s  % N! x1 U1 C" |8 h7 T9 U1 [' m6 e
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    * Q3 y. {3 r! }# ^6 R                                
    * G/ g, |5 E: b! ^+ F: g                //Method - 2  N=100000  237s- S( [, ~- X) ]$ s% G2 I% L
                    /*
    $ W8 r; |& i- j! U# x2 ?4 i                for (int jj = 0; jj < N ; jj++)3 B9 g+ e$ I2 N. Z
                    {$ V9 @( B( K& ^' ?% g# ]* y
                            fresult += vec1[jj] * vec2[jj];: C8 u* ^; E4 u) z
                    }
      l7 p* E  {$ D7 o8 F* n. R                */  ]6 q  T: f% q" y3 l
                                    
    ' a8 ?8 E3 s/ O. V5 a2 Q                //Method - 3  N=100000 204s
    ; p$ v% b. I2 ^0 D8 S% w# Q                /*
    , a" t* B; }2 U0 w) [" B4 p* L" v3 N9 r# S                for (int jj = 0; jj < N; jj++)" h3 q' a3 U6 U
                    {: d& R9 |1 \( L( A# q0 l
                            fresult += b1[jj] * b2[jj];
    % k+ n0 d+ `" o% g+ v- V* ]                }
    ( l: `: G+ [! u' B/ G                */1 c- I8 P' U5 J0 ~5 y" o! @

    4 N/ R" Y3 f; t, P, Z7 D( w( ]3 }                //Method - 4   202s3 ?. _2 s5 q( h- ?
                    /*  j# y& f9 V- ?# e0 |
                    for (int jj = 0; jj < N; jj++)
    ( K1 K9 X6 T( K( R4 d* w* Q$ j2 {                {- C0 r" |0 O( @+ S$ y! Z
                            
    : H- N  u' X8 i, Y- ?- L6 ~* i                }# l. B$ S2 y/ k3 L
                    */. Z0 Z9 \# I! M# D/ E
                    //comment out all methods, N=100000  202s                & Q6 p9 Q% y& B8 G8 ~1 e
            }
    1 X. [1 x) E& W- |' a
    ! x8 g# c& G& p2 d7 S9 K. m8 ~        delete []b1;
    # h7 Q+ P# h) e9 ]# {' Z- Z. _4 u        delete []b2;
    + B5 H9 C2 F: o5 {6 B8 j
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?+ V2 ]! P# H0 ~4 M4 P6 s! ~

    ! ^; e. n4 C$ i8 {' g  A! |$ I你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?1 I1 }* W3 \$ z8 f1 c( U
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    ' W" N- g. R4 _9 H瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    4 O8 j6 }( Z. h# }3 t6 J1 ?" [  y( r8 Q: Z) L6 {, J2 n. v$ s
    你第二个试验里面的j在循环里面又重新定义 ...
    ' R2 H3 |8 V" N
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL4 p# D/ w0 l& h! k) n

    : F7 G  P; l. a- y- B/ |不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    5 d; \4 l; f6 e1 G. h内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    , V$ P) |% u' W' E% b% c; c0 }+ E6 T7 f1 \0 V' d
    不和它 ...

    8 D6 Z6 h/ D( c" U  |5 L3 u' c: x5 W+ n/ x
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    4 y# K6 l7 U: X. R0 B/ Y) t后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    4 d: X5 V4 _0 p6 a. G- e: Avoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)2 U5 X. J$ [+ g
    {$ s; S4 n- b3 c7 q
            comp temp, xtimesy;
    ( j+ Y( h$ H; g& [8 m' a
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。8 D3 z! x- J4 L( _
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    8 o" ?7 X0 Y" Y- T# fVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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