设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    & P1 y1 W2 `( d6 D( a& M$ [, r3 S+ |! H7 r  ]
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。8 x7 ^9 z5 M/ x- x9 ^3 x) c
    9 z2 {  t* v7 a4 D/ f( h3 i5 I
    速度优化问题真的很有意思啊。4 |" r  ?& d- E: e

    3 t, {! @" a. o( f欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    & }  [% W- ^1 E; {把代码贴上来看看?
    7 J  Y* w, S! S6 |, c
    ! F/ u- O* w) Q# H& n难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 4 s1 Z5 I# I5 l3 F
    数值分析 发表于 2022-9-24 23:04& C: W, k/ z4 i3 Y8 j
    拉下来?拉多少?
    / s- }9 _8 {% k2 N- K把代码贴上来看看?

    & o: Y; r$ N  [9 t* u& h2 _" J5 i% y0 p2 l3 X. _$ O
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    0 |$ N3 I. U8 z8 A( U{& B. _7 r3 _' v/ T; P9 w. G
            comp temp, xtimesy;
    % G) I" n: y" S. s        xtimesy.re = 0;1 P) K9 R: U8 ?" n" f) F, S5 B
            xtimesy.im = 0;
    2 M# `/ S! _. G        int j0 = lenB - 1;" \5 }. H; w; x4 l& {7 x1 ]
            int    i, j, i1, reali;
    * e0 }+ g+ e, p; q  N        if (lenA % 2 == 1)
    2 t) v( p% ?8 J% F/ z" n; k                reali = lenA + 1;9 ^/ P! D0 ?8 P" T) x
            else
    - `$ q# u7 m: u                reali = lenA;7 ~* f* u$ O, o7 u; g' X
            reali /= 2;3 N4 ]  K" f* T. C, V9 u8 O8 T

    5 ^6 L) S" y# a- a        int nconv = reali + lenB;2 s9 v+ H2 R$ s# W1 W  s' l9 U
            //#pragma omp parallel for2 x" X8 u1 B6 C3 g
            for (i = reali; i < nconv; i++)
    , y7 P3 G, d7 N        {
    " U/ o+ e/ b: ~0 {% [8 R                temp.re = 0;2 u: g1 g8 M- i4 j7 K4 p6 R) a2 _
                    temp.im = 0;
    6 J; |; R4 W7 F. k$ m+ V6 x4 b                i1 = i;
    & r7 x. Z: s) b* `2 x  H! [                for (j = j0; j >= 0; j--)8 d1 a* [" \6 i8 O* w& ~0 Q! x
                    {0 e1 N. N+ y  h0 \. K- d8 d9 m1 E3 v
                            /* floating date operation */3 n7 L5 p! B# q( M$ p
                    }

    % a  n% z& i- N3 O3 O; T1 ~- w        }1 }) y& L! V$ ^
    }
    + ]9 q! w3 l( Y  c$ f% h
    1 `* @3 f" C2 E/ o: |/ f0 }0 Yxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样! `' D. ^# z" F

    6 t2 R8 [0 Z6 y  a红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。" s' C  f* [; w9 T  @
    现在call xcorr 100次,耗时78s.
    $ Y+ t, l  ^1 @: w5 b' k* \% g
      P( B3 G% m) z: P" n0 K3 s如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 2 w3 p8 S# a  u! [

    * m: a0 }, Z4 [% F. ~
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:335 T; j" ~3 {2 C' F0 M
    Maybe Debug mode?

    : {7 `9 N! d# j* s7 r& t: N2 O1 Q  n1 \) }* f  z% Q( D/ J3 k
    不应该,看我上面的回复。
    # f; d2 W8 V3 O9 h( q/ p% V- k' \5 M
    . }* b  r4 ?8 B0 W5 L* _4 z我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 8 t1 p- _$ k4 x( _$ R' d: D+ W7 T
    雷达 发表于 2022-9-24 23:546 R1 F& r2 ]$ n
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)5 Z3 M- O# N* b, I# s6 j! F, R0 |( E, K
    {
    ; F1 h7 X: K" v8 C& H9 ?        comp temp, xtimesy;
    2 F, E. s8 `/ p

    ; J3 P. f( Z3 E$ B! U这个不是这么比的吧。。。
    , X1 M( b9 z' [! i' z
    : P4 e! |6 H9 g2 V您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。1 H* A" A% ~3 }- h

    4 G& H. d3 o) h/ v3 e: U4 V$ `9 a/ n+ E而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    # s& L$ ~+ q8 d! ]" k1 T$ ^/ d2 x
    数值分析 发表于 2022-9-25 00:202 c7 `$ [' g$ U3 W$ c
    这个不是这么比的吧。。。
    ; {: ^" Q! ^' a! ~' x/ |+ f5 c1 N" I& u# a# L
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    - b" b  z7 c0 o! @
    7 J/ e/ D# i- Q9 v有道理。
    0 i, {/ {, a+ e+ `) v所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。. Y' `/ {- h2 B
    2 d' ~1 E. g8 ^: b+ C3 D
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    / K% ]  d( @) ~; I6 P4 s/ R有道理。
    2 C/ C/ }1 g1 }% U. c3 P, O所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    9 E6 Y: y' D" a/ U& n, f& ]你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多* M0 T! x3 ~$ W) v
    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
    0 n- V) h: a1 u+ k1 m这个不是这么比的吧。。。6 I0 F# y# d. K% m" n& w4 z6 Y

    8 P+ ~0 |7 |2 ^5 D5 y0 v2 z  S2 x您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    0 M2 ~, u4 h2 P" l9 j. k
    3 R2 \( N& h( W  j: ]现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    3 y8 _+ L- j* Q
    沉宝 发表于 2022-9-25 01:48
    & ?- @% `; j# _5 T/ G6 e; }+ Y, f现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    $ g& e- I  N* ^0 N) E; y

    8 B% T# M# \$ a9 q' f& H8 y: @' {  K是的,兄台说的对。
    7 Y2 C5 ~% H# Q: h4 W/ S. |9 d( k) }) }/ v2 ~5 X# d) `
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    + L5 S  p* A+ `. p/ r$ X+ x) m/ h+ W8 G/ ]2 Y' n+ T9 x
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。' w+ j; i- ~0 {0 i+ H0 c
    : I1 r, a! {0 u  E0 n
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
      d# p" \% ~4 \% S/ P9 x9 b( E/ [+ g4 e6 |& p9 D4 v" Y. z
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 ; e5 j1 H. \  U% F3 K) ]; ^  d
    沉宝 发表于 2022-9-25 01:27
    # Z6 G+ |, y" m1 |6 x你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    ) K' N' Q7 @, w  X2 X
    2 \% k( l0 ^& E% H
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。- S" w8 }7 a/ e, C

    # f9 E2 n' h- g" o, |6 X/ s- Q我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    7 [' G" s3 l' X又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    - d  M$ b$ C& R: n
    时间差一倍的结果可以接受。
    7 m  o/ d" G( f& _1 _
    ) c& l. d* @. ?& T  ]你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 : z3 Q  e4 Y% s. ]" ]" M0 v
    雷达 发表于 2022-9-25 04:47
    ' D$ _: x$ n4 e* q, D" Y# ?* y又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
      Z  E& N# K, r6 p& G. X6 V

    3 F1 I5 a5 n, }* n( }6 U- {, R  X$ \. R' E* V/ P( @

    2 ~# e* m9 N! F7 c+ N7 k, Z# F能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
      c4 E( ^9 U5 }" l
    数值分析 发表于 2022-9-25 14:58  C$ P8 S8 f* j# Z4 B& i$ @/ a. x
    能不能把这个也贴上来,看看和上一个有什么不同?
      [2 \; l4 B+ _8 C# H$ k
    理了理思路,重新做了一个测试。1 K, L: K4 y& B; G
    做了两个 vector 和 两个 float *, 都长 100000
    - M$ z7 ]# _- V8 [( `4 Y, n外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.3 N0 o- f2 J3 P! {
    2 L8 m9 G5 V8 E) \' Z* C; T
    内循环试了4种方法,) s7 G6 s5 b! W% l3 s
    1. 直接调用 vector inner_product 247s 9 m9 s5 A6 @7 B. b' @* ]
    2. vector 循环点乘累加 237s4 H' a# ~5 ^# X% n& n4 x+ R5 w! w
    3. float * 循环点乘累加 204s+ O( b, g4 Q; T+ V
    4. 空循环 100000 次 202s% J  G5 K  j4 g7 D* b7 E
    / L1 T$ x2 p; g2 N2 z
    不做内循环 200s6 _2 a1 i% q- M% `

    ! B! p( Y. A$ N: j你昨天说的对,内循环本身占比是很小的,大头在其他处理。( H6 c2 r1 \( m5 t
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    & ?3 d3 u: Z; w8 Z# p
    * {% a. g/ c. Y: X% v至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试). q, c6 A3 ?; I( B% t4 g

    ' [! [! x4 n+ E# y2 k# L(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)" C( D& a) ]; {0 r8 M

    # [: \; {8 i. S% |
            std::vector < float > vec1(N);
    ( C8 b- ?* j5 z. g9 H/ G        std::vector < float > vec2(N);9 ^0 q/ @( P" N2 K. e+ c  X
            float* b1 = new float[N];( `( O- M% D- f! |8 L2 w2 ?1 K1 j
            float* b2 = new float[N];3 s" h& A& H! I+ G+ K

    & f4 t  y' x: ~' s        for (int j = 0; j < 6000; j++)
    5 s8 m( W; d- P% d3 b: c        {# ]2 m3 W6 P8 M% z% f
                    std::generate(vec1.begin(), vec1.end(), []() {# w# G& I+ d) D
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ( g9 B- J  h5 p+ o2 b& l6 K                        });
    9 b) X: U( A4 A6 _
    " \; M) q+ t, H+ Q# O0 S: z                std::generate(vec2.begin(), vec2.end(), []() {
    1 m4 y0 j: z$ R+ T                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;) u3 t" x# c5 O' `1 R# k
                            });: [: i/ T: Z0 A% P) F, d

    2 `' G& O+ g. r& m1 R% i                for (size_t jj = 0; jj < vec1.size(); jj++)
    + K# O9 y1 i  T$ C- e                {
    $ W0 ^: T0 g: `! O! Z+ X5 c                        b1[jj] = vec1[jj];$ t8 L9 u, l7 {0 T
                    }
    / g! t3 r2 @; e; ]- Z/ ], R. `
    - M- N- ]) T8 @# I" u" B                for (size_t jj = 0; jj < vec2.size(); jj++)5 d/ _& B( o3 O7 A( ~& }
                    {& q9 l" k5 J$ E) m, k8 T) i) J
                            b2[jj] = vec2[jj];
    $ Y: Q9 ?- M1 K5 B9 ]) ^                }
    ! D% f6 x0 \  |; ]9 G$ u# l
    , Y# a9 F# l1 m" r6 y                //Method - 1  N=100000 247s  
    * p) n/ j9 ~, h, ?; G% E                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    8 p  H! U- D& Y& y                                0 N, Y6 x: z' \
                    //Method - 2  N=100000  237s  p4 r/ C/ s, i- x5 }
                    /*
    . o' x8 j+ w. |, M, |5 A                for (int jj = 0; jj < N ; jj++)# s7 s/ v: ?' H1 a/ h, h0 c
                    {
    , O, h( x: B+ r% J                        fresult += vec1[jj] * vec2[jj];4 w2 c" [* \& A: o
                    }
    # @  I5 j. z, n                */
    0 Y3 P' L4 K- M) N9 ~  n+ B* B                                $ m& N, x% U9 M& p2 Q7 X3 l, M
                    //Method - 3  N=100000 204s8 b( Z8 S2 m: p) Z- g& H: h3 G
                    /*9 |- V2 l9 b  _8 m! c6 l: t! `& ~& j
                    for (int jj = 0; jj < N; jj++)8 b% o3 D0 W$ W- v" m9 l
                    {! b3 k" f" ^  v; g
                            fresult += b1[jj] * b2[jj];- k' C( n/ g/ f  S4 P' |4 a/ X
                    }
    7 d% \% @3 B9 e6 j$ q                */4 n' e5 {( B) |$ \) i

    2 O3 D+ x6 M) X1 p& j                //Method - 4   202s" e+ O6 ?2 W7 y. j  D4 b
                    /*0 f5 a: A7 ]0 O- ?
                    for (int jj = 0; jj < N; jj++)
    2 E/ L5 |9 F' ~# H4 i1 _7 Z                {
    ' V7 M' H' W. T/ R                        + i1 s" C- E+ c- e2 n' Q$ D" J
                    }; y1 q; E9 t9 @: ?
                    */+ e% Y* h" z: r9 m  k7 y0 e4 u5 I
                    //comment out all methods, N=100000  202s                ' q6 U) d- @' W' X/ c/ o; U
            }. q  ~& m% m& D2 ~

    ( K, U" Y  l" o5 W  M5 N: W* n        delete []b1;# C5 f7 |) k7 k2 h: Z4 X
            delete []b2;

    6 H2 I3 S; ^( C5 e1 G
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?- y3 Q% r& }. q. C6 P
    * Q5 u3 s% K* v
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    8 M9 n) o. l/ L& a; E1 y
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:152 t1 ]! l9 G0 d+ p
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?0 l; j7 P& w: O
    % d; W1 K; W1 I- f+ l3 \) `
    你第二个试验里面的j在循环里面又重新定义 ...
    - i$ u0 c" c& n$ g6 u' o1 @/ B
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    8 X& ^( Z3 c* K. {7 E! r  r# H' u6 s$ O
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ! L$ X' y. X* z" c内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    + d0 U+ V7 n! H* A& r2 K( ?4 j, P1 s; n0 z: U6 C4 d8 L; y8 R
    不和它 ...
    7 P7 I4 b1 h4 m" {/ @* h% F
      D" }. P& l+ h/ Z# u- s
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。$ `- A% b4 J6 @1 O1 Y- A+ J
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    9 q" k6 ?7 ^/ K6 avoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)( Q" ?' a, d! w& w9 R6 r
    {8 u. q/ b( ], |5 C8 Z7 w. S! m
            comp temp, xtimesy;
    . o8 G& `. \. ?8 a
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    $ ]0 d1 M2 j4 _" @# f8 Z  G1 P内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?/ j- c4 g9 z9 v8 ?5 v1 t2 Q6 _+ E7 A
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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