设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    : a3 e8 T  `6 G9 Q$ _2 J- q( p
    8 G! \* K" K7 T! b4 T5 S自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。) X- p' o5 R( o0 L2 j. Q6 r5 r

    2 ^  G5 j- Z9 z' v% X7 X速度优化问题真的很有意思啊。
    1 {( z# u& r! i- ]9 g" P. N
    7 x5 S) W7 S5 ]欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?9 e  _, W/ s0 {% e& j
    把代码贴上来看看?8 q/ J! ~4 M8 a
    6 ]# S& _2 p* \0 f& h; w
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    " _7 X9 r- T1 C' C3 d# c
    数值分析 发表于 2022-9-24 23:04& M2 Z# E0 ^! `* m
    拉下来?拉多少?
    , q) O" ?* K; C' ?# b把代码贴上来看看?
    , `3 X9 j* j5 f  [

      L+ x1 i( ]" l" C' o4 M! ]+ fvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    4 j9 X2 p( ]  R+ s7 N9 ~) ?  E{% W  x: ~' k, n. H- g
            comp temp, xtimesy;
    3 a( `% `" i# x0 e8 F0 Y/ l        xtimesy.re = 0;
    7 o1 W" K) d  {7 E7 ~3 J( f7 v        xtimesy.im = 0;
    # R4 {  b# v3 d+ H0 m        int j0 = lenB - 1;# ]/ @. \9 t$ h* K' P# k6 h
            int    i, j, i1, reali;0 @1 H% k5 s$ v& ]* q6 V/ F- @
            if (lenA % 2 == 1)
    / A  V) z8 N, t0 W$ v/ r  g9 N                reali = lenA + 1;
    7 w( v5 w  K7 T* }        else
    1 j' e' W0 ~+ U* i. b1 @                reali = lenA;
    ! D5 s% Z( w4 F. r+ g        reali /= 2;7 T0 G3 a3 y# C* z2 h
    7 a! c6 q, `" Z3 E
            int nconv = reali + lenB;+ I1 ]# q( b( y3 M
            //#pragma omp parallel for( C) v+ o. i: \1 B: Q
            for (i = reali; i < nconv; i++)* [( I( n) d# N' E2 l  T8 u
            {' P: w: l( N* \0 w8 s
                    temp.re = 0;
    3 N* w9 R7 S- c0 X8 g' W5 \                temp.im = 0;
    ! E/ j  l! O) R( q( b% ?                i1 = i;5 a6 @3 n" U! z1 i+ z' T
                    for (j = j0; j >= 0; j--)
      a5 v& a" c* l$ c' j                {* B& j6 m9 V4 _+ c
                            /* floating date operation */
    & I! B' B/ ^/ s0 z! w# x7 K6 x) A* R                }

    " q4 C5 d) Q$ K        }2 o4 r- A7 M2 V3 ^1 g) U
    }7 @' o, _0 s: J: S
    ! J& x* u( p1 \9 n$ J' m
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样# b4 O5 f& Q" o0 G9 n, L0 s
    3 J: Q- C0 [: e! [
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    ( S+ _* U/ j/ |7 H现在call xcorr 100次,耗时78s.2 `& z* c: y7 \, m; Z
    - f! i; F: h% r
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    2 i* U3 R& s7 R" X" R0 Z, l" [' q8 {) S  t5 h* e2 A
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:334 H6 L9 V, w: e9 B4 k# H+ a
    Maybe Debug mode?

    ( ~# p+ Q, \& z' t7 E3 D" D5 H1 p( v) `- }
    不应该,看我上面的回复。
    + c2 J; H) [  R! }
    4 Q1 Z" m" a2 a* H1 V& M! c我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 ) U( A4 M, b  v
    雷达 发表于 2022-9-24 23:549 m0 c: O6 \* R9 F2 b) P' H% p
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)# i& C$ }0 q* @$ f7 f' F9 a9 O
    {# q3 o2 K' t. F( H8 ]- G" l: p$ _6 L- i; c
            comp temp, xtimesy;
    : n0 W$ H5 S0 g' ~  q" g0 e# X

    * m9 c6 O% z+ P9 C) x# d% l这个不是这么比的吧。。。
    4 P4 o# ]8 T# V8 Z5 I3 k
    : T. B' L! X7 Q8 m  t3 u您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    0 b+ }; O$ L5 X/ F- ]; A: W$ H4 K- V) B: F3 x, X6 J% J# ]. c5 G
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    , v; z7 Y' p8 |  M" U- @7 n
    数值分析 发表于 2022-9-25 00:20
    4 m# U5 Z& H- \0 G6 U* c这个不是这么比的吧。。。
    4 J' x: _: [* ]# P! y7 b  ~3 A3 m. s/ i& `* P8 y" ^8 D
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    4 |7 R3 E* j) O4 R" S4 Y$ V' F! E$ Q* W$ k

    & a# W5 U( {. Q有道理。# A; |' m# ~' R2 @9 j  k
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。- K3 v' i0 T" `, Z9 E. O  u  l
    8 ~( o6 N+ A, h6 Q) r' V9 V
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46  z& K4 a. [* h! [
    有道理。
    % Q7 `6 U* W' l4 q所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    ' e- [( k9 O( t3 D- B/ t' z/ \你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多8 g" d* ^& R+ T- |
    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
      B" R: P+ O( m, c, @' p3 ^这个不是这么比的吧。。。
    9 ~* n: q9 z4 j* Y
    3 ^; s6 Q! Z" |! [% |2 Y您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    - G" P, G8 E2 L, ~# D4 c7 C% i# y! @3 k5 Q1 Z) o4 }
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    $ [+ [7 D3 @, j" H! u
    沉宝 发表于 2022-9-25 01:48
    ) E$ u8 g% ?6 n; i4 S/ J* Q* A现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    $ V' b+ ~( j- ^  g3 m: u7 x2 m& z5 r% z0 J" e
    是的,兄台说的对。( j: c( ]& q6 {
    $ H) W9 N* i4 [9 Z/ }
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。9 s$ Z5 T  Q/ x1 u

    1 Q: O# d% q: M; M2 v' B5 |% I雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。8 V" |# ?+ H( L; i

    # v  x: T/ L7 T( ^比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    0 V% [! u3 Z' l, _1 A6 G
    9 K% v; u, f! I0 H2 X3 z' n# N当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 8 B: N+ [, d* x5 N
    沉宝 发表于 2022-9-25 01:27
    6 |$ ^$ u0 S  C/ b0 p! c! A你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    : \0 _0 C6 w7 k# q1 \2 l7 Z6 B4 T0 W
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。+ p1 R. ]$ a' |2 E. N" z! W+ u% [
    9 X8 r1 x: b8 o' W  x. Q7 |
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    : {1 x+ \! A# C& c! z* s. G2 W* Y又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ! e% n+ c6 X8 v' [4 y% }
    时间差一倍的结果可以接受。
    + d3 @; o% c5 v* E% |1 C3 l5 S3 U2 ?6 c6 L
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 . A/ Z5 ]( ^6 u* n/ g
    雷达 发表于 2022-9-25 04:47
    / H0 \) U  V$ k, \, J/ |" S# \% }又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    % J4 V" _( c6 P5 K9 l- G$ K" L
    ) K* M6 w2 L2 u4 l2 y* K6 }7 v% N4 b# Z* i( m1 s' z" Z, g8 O8 H. n

    7 g% n6 x7 _: B! r8 R+ R( a6 b1 X0 ?能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    ) H$ ?' I/ r7 o3 C4 e# ]
    数值分析 发表于 2022-9-25 14:58" V1 }- I5 `5 H! ^
    能不能把这个也贴上来,看看和上一个有什么不同?
    4 v, A7 H# b+ d5 F7 ]2 D
    理了理思路,重新做了一个测试。
    + z8 T0 V* f. P2 f7 J$ Y做了两个 vector 和 两个 float *, 都长 100000
    5 n2 u& T! s- H# w' J" t/ f外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    4 r9 U) p) |% k; `* a0 ^+ j. E# W" H6 n4 C
    内循环试了4种方法,* N+ I) J8 J/ R
    1. 直接调用 vector inner_product 247s   Y1 W$ ^) a9 j  h7 S* p; M# q
    2. vector 循环点乘累加 237s
    8 r( o; M/ @  v1 L; g3. float * 循环点乘累加 204s, `6 _6 K6 z$ N- d1 T
    4. 空循环 100000 次 202s1 _  I- k# O% P6 U; b8 R! v
    7 `& N5 |  _! g8 i, _! u
    不做内循环 200s  g4 \7 K8 W+ S# b) Y. i) k& A
    ! A2 o# k4 U3 \  k
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。: f+ [2 f, G* ?1 J8 d
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。% B, i5 z3 C5 n& n/ ^* R

    - P" M4 g- J8 ^3 C+ \* z至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    0 D% J0 n! g8 K" I) k( d* p
    ! O& h* z# q' d' U3 [(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)+ q; n; q# y( J( ^+ p" [; O: c  I

      a, G. R/ E) }9 H# W
            std::vector < float > vec1(N);
    ; F* }2 }- g5 F" `, R        std::vector < float > vec2(N);
    : y2 y) ]- Q5 f        float* b1 = new float[N];& E0 B5 P% }4 W4 u$ Q. c7 N5 H; v
            float* b2 = new float[N];
      d2 l5 _% h6 G$ l  a
    " u9 E4 Y# Q) K* q        for (int j = 0; j < 6000; j++)- H( \0 z  h% f* {+ c2 ]; f
            {- G9 a( A. e( m' {+ a( h+ J
                    std::generate(vec1.begin(), vec1.end(), []() {7 r- E) |4 ~: Y' `. Q8 X5 ~" Q* C
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    1 P* y6 |; Y  p( i- }5 J& j                        });
      J& u' n9 q& M  v; H0 M! r+ M: k! e5 @% k# N( c
                    std::generate(vec2.begin(), vec2.end(), []() {: {; F' y) }+ A% y
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;2 i  P3 g3 X; v' _/ @
                            });
    6 S& M0 d2 a! }  c, m& l
    ) q& _( c$ w- [; I, \. O                for (size_t jj = 0; jj < vec1.size(); jj++)
    $ g0 x  i% F" ?4 i                {; B- {- t5 e* a0 |$ _7 z2 `- x
                            b1[jj] = vec1[jj];
    9 E) n. O3 L+ n3 m% g9 f0 v9 v                }! a9 M4 p. g' a! ~

    5 W$ ]  N& x9 |                for (size_t jj = 0; jj < vec2.size(); jj++)- a& t7 F2 K/ u2 W8 u) A
                    {
    ; A7 C- y* R) k                        b2[jj] = vec2[jj];
    0 ]: Y8 a7 d  i                }
    ! o) ?  z: o6 B/ O7 \# O+ l" C. D% c! V" Q3 v/ P4 B4 E- f1 m
                    //Method - 1  N=100000 247s  9 j. M. X* x) R
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);2 ~1 H9 Q; r3 z3 y/ F5 a' {
                                    ) q4 [! b) N+ i2 j; S* j
                    //Method - 2  N=100000  237s0 F- c, u( @1 d4 K3 N
                    /*+ W+ t2 ]9 b% I, }3 f- Q5 Q
                    for (int jj = 0; jj < N ; jj++)
    - @' C  V' v2 l3 p* m9 ^4 E                {( e# |' i/ W' ^  [4 @  |7 O; r
                            fresult += vec1[jj] * vec2[jj];
    8 G' I, L! s8 L1 j; ~                }# h3 u2 `8 H( V1 \8 P
                    */
    , Y1 z) B/ V9 x; J' p! Y                                
    - F3 l- S9 v- w, i; U                //Method - 3  N=100000 204s
    + y  ]) Z: i: H# K  h                /*
    : L4 }; x- K/ u! y1 |                for (int jj = 0; jj < N; jj++)
    % f! h# [. p  v% \$ ~                {% q6 s) K% y$ u5 W9 K
                            fresult += b1[jj] * b2[jj];
    & D6 {/ r2 l" ]1 @                }9 D3 |4 p4 ^9 [/ I$ L* @' @
                    *// @" G3 @" ~) A  L
    4 {# b  q2 M- h  {( a
                    //Method - 4   202s, t- D. e& ?' u
                    /*9 X3 x! _5 U3 O( A/ G4 E# i% m
                    for (int jj = 0; jj < N; jj++)
    & O% j4 G4 H& Q+ }7 i                {
    ) V; h) ]( h" L+ i0 X# I! j                        
    0 R1 M& z, H7 f, ?8 d  B% D$ j. h2 V                }
    ' ~( y0 R) ?6 z# B& z3 g                */7 t6 K% ~% v/ G8 T
                    //comment out all methods, N=100000  202s               
    : d4 Q% i9 P! w" D8 U! Q        }
    $ N1 \: G- u/ M3 d  z$ H" k2 U! ~3 ?0 T) c3 m8 i- L
            delete []b1;6 e4 I6 ?/ Q, C  T( z5 S
            delete []b2;

    / k1 o3 f8 q7 i6 J
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    1 Q! n; T! P; C1 m( P$ v/ `0 H" v1 O/ R. O  v  R; M
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?' c4 I, q9 U6 z4 T
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    - k" K/ ]4 k1 F! O; E# q瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?. v9 S: Y* d: j4 s1 f/ {
    ; `; E6 `9 r) G9 |: u
    你第二个试验里面的j在循环里面又重新定义 ...

    + z% Y! Z4 y4 E- ]! M- N内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
      }8 l+ ?; }# ~3 f, w& E  _9 V0 d% c: B% j
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16: ?# d& R# F; k9 U9 z5 _! I' @
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL5 Z9 b: Q: m, }( a# l
    7 D5 M3 e. P$ W+ x0 \5 _1 [- X
    不和它 ...
    & F* @+ O; M& ~- K

    0 Z& D2 P" \; \! h7 ^: i& H不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。0 m1 s; {; \! D1 J$ {1 C, D
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    4 R2 P6 h  K8 tvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)4 Y, L; B. |. w6 h* J' l9 q
    {) `' @9 m9 i; {3 E. A4 P+ }. y
            comp temp, xtimesy;

    9 t& @- R8 k  U" r这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。, [* l8 z$ x* d6 g# \' ?  O6 z& r
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?) j! z, e. n+ X: _5 W- `/ x: `& V
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-2-19 06:37 , Processed in 0.040520 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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