设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    7 Q5 O, G4 G' Y. }% T5 w: e; _; y, t4 B7 Y: d0 z+ V" ^+ V8 u5 g
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    / h  p, n, j4 B6 Q% a. j6 s" N* ^. ]; _* t8 [+ m0 W
    速度优化问题真的很有意思啊。) t$ r0 Y9 G  G! |

    ) O) \: Q9 P. j" Z  ]# @欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?# ?" C) b) Q" ]+ L4 v% ?& W0 M
    把代码贴上来看看?
    , k3 U( L. l& e# B) e, ^7 t  B' l6 X; K" 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-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    ' p6 u8 L) p) s# l
    数值分析 发表于 2022-9-24 23:04
    2 r& J8 r1 o1 g% ?# c8 I* Y! p拉下来?拉多少?+ V- {& a5 n# H
    把代码贴上来看看?
    9 ^, v7 F* ^! y0 E& g
    3 T7 I- U( O4 @0 I/ K4 k4 _2 d
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)' Y% P  m4 V' _% `6 q; [% \1 a
    {# i' S) E$ h5 f) m
            comp temp, xtimesy;7 x, {6 i- [' ^! P  B; h
            xtimesy.re = 0;- p- @$ J% @! R1 O& l1 ^
            xtimesy.im = 0;
    , r' l" R% M! ]        int j0 = lenB - 1;
    3 D5 U8 q! Z2 k# g) ^        int    i, j, i1, reali;
    4 P: d& u9 a) P: F3 I        if (lenA % 2 == 1): j2 ]. U9 i3 Z" p, t
                    reali = lenA + 1;
    , X+ V" r7 ^7 U2 ~        else, k! \3 O1 ~% @, ~7 k$ M4 p0 W
                    reali = lenA;: P7 U& }& z7 j0 c  Y5 m
            reali /= 2;
    ! x# J3 C, T  V+ L# c5 w; k3 f! z& ]
            int nconv = reali + lenB;
    # Y  x! `5 z3 O7 O. Y1 y  I        //#pragma omp parallel for8 f3 f! Q2 V- A. H6 u
            for (i = reali; i < nconv; i++)9 Z) i, ?8 @& w
            {5 }" a) Y- X+ B6 M2 u
                    temp.re = 0;. ?- ^0 Q3 w2 T) S
                    temp.im = 0;, Z8 G6 ~- s1 q" Q: B
                    i1 = i;. ]  `/ G, U! R6 |
                    for (j = j0; j >= 0; j--)
    ' \% X0 _5 m% H2 i6 d                {# o( m# C2 a- T: Q, {
                            /* floating date operation */
    . }, z1 T! w/ U& y& k                }
    , o7 I. Y/ K& e
            }. E  T, W1 c7 S) E0 k# T
    }) F8 y4 l. V8 r8 }

    , b. {8 w  R0 s* Wxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样5 Y4 `1 S7 s! k, K) N
    : J8 t$ X. O2 N5 B6 B8 F8 @9 ~1 E: X
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    # g) f+ X7 g% N; |" Q现在call xcorr 100次,耗时78s.
    2 U- ~5 Z. R4 Y. U2 e5 T$ I  K$ `9 x  ^0 m1 o' C2 E
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. % v% {1 n* e) v1 L: z
    , N7 m+ O6 z1 }$ y" E: U) ~: @
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33& m* @' G2 I( W2 i: k$ p
    Maybe Debug mode?

    9 A# f4 T: E, B- L
    2 \; o/ k- T, S! V) S) Z) \# t不应该,看我上面的回复。  i+ v2 O2 i% Y. H# y7 f
    ) M4 v8 K" u. L3 c( J& X
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    % ~3 O5 g6 }& J) ], T9 s5 I1 `
    雷达 发表于 2022-9-24 23:545 V7 G; V5 N$ c1 d) _7 f
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)9 b! P$ o' x7 Y) w8 y  a
    {4 [! S, W! c! C+ m6 N0 e! `# ?
            comp temp, xtimesy;

    7 B/ e. `  d# [8 I* `
    6 Y: c; R6 x7 C9 F; c这个不是这么比的吧。。。4 j3 I2 J' S9 `* V* ]

    4 I% [* d& o7 C+ m/ Z2 }您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。# d) a+ t5 k% m: l
    / q7 n, d" ^  a# {4 V6 `1 ^
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    ) m* Q+ E& P) S$ \  @
    数值分析 发表于 2022-9-25 00:20
    ; b- C, |6 W2 r" l  T9 Z这个不是这么比的吧。。。
    9 N; b/ x  ]2 J4 f; f5 q3 F3 N! K) y' v' f! L: f# [, I, [
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    . G& |7 ]! l4 b4 t) I( `
    $ }: M! D- [1 N9 H- r8 D
    有道理。
    ' Y1 |. \9 F& d* K所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    0 W& {* A" f0 h0 T# [8 \
    * @2 ?4 s% ?& ]我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46' p7 X- m/ r0 d6 z9 n9 x
    有道理。8 u* `, g" z  O4 k# w0 v
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    1 v' t6 f* O* A$ I
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多) k1 n( x1 ]/ U# 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
    7 d5 F. V2 C  n0 J4 Y* k这个不是这么比的吧。。。1 m: A) \, j" b+ l0 _1 L

    6 `( S2 h" X9 J# q( @. G您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    / m5 R- p. N9 d5 v9 s4 a+ K1 W+ R, }0 {( m0 Y
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    ! S8 M! U, R" _6 l
    沉宝 发表于 2022-9-25 01:48" R, q$ h5 w6 g9 j! ^/ M) _! s
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    . s) }3 W7 `# Q

    6 ?/ W) B6 r+ m$ `% |是的,兄台说的对。
    8 ?1 H- _* ^( g( [0 U8 R/ U
    , ^; |0 x- j) i& L  Z, t" R/ T" |其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。. j6 Y( I# h4 p

    8 H( }! e' j" q9 G! ^& b# H5 X雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。) N8 H' A: f% k1 Y) C5 i9 |+ e
    4 |- ~% {4 Y" x
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ; m  x& _0 b5 s/ J  u# o+ p: M/ f* B& S" l
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    ( f' u0 T, K  Y
    沉宝 发表于 2022-9-25 01:27
    - J/ ]. M' @+ E. g0 X6 J* J- P你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    + U% H3 V+ S: a7 F) s8 X. e5 X2 r8 i4 K$ ]# M
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。- \* ]0 B* f. R; N7 i

    ' @) _" e, ?* H2 O% E+ E/ B我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    7 I0 m% a+ A. h! o1 Q5 u又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    2 z  k* h2 g! t  S3 O
    时间差一倍的结果可以接受。: d# W# ]- \2 G; e4 M6 c
    1 ?; T& v. d5 [' T8 x9 m* q
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 ) E% @& Y- m' k" ?! {& {! Y
    雷达 发表于 2022-9-25 04:47
    ' j( o! t9 D' A% D2 v又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    # `- Z2 N2 y! A3 z" U6 z
    ( L8 E% v7 d( S& [3 Y
    8 w/ v& l) s9 x7 |/ v

    # ]; \0 @1 w& ]/ l+ @能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    ( m6 H$ g: Y5 w, R! f2 o) S8 A
    数值分析 发表于 2022-9-25 14:588 d( @. Y4 Q5 m5 M4 m6 D5 @: ]
    能不能把这个也贴上来,看看和上一个有什么不同?

    : v  R; T6 u1 {) Q理了理思路,重新做了一个测试。! g' @8 e8 y; O( E
    做了两个 vector 和 两个 float *, 都长 100000
    # ]6 \- O8 L8 ]$ W! b3 g外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.5 R/ k9 ]& X  e# L& v" _8 [
    2 j& y  Q7 e. s  U) [# P0 Q
    内循环试了4种方法,
    + x1 Q, R8 t" i6 ~1. 直接调用 vector inner_product 247s * ^: h  T% W; {( [0 t. ^$ _$ G) P
    2. vector 循环点乘累加 237s) P5 @/ m; M  d1 w' x( ~
    3. float * 循环点乘累加 204s
    7 J, X( f6 I8 l+ q4 A* @0 s. w# R. Y4. 空循环 100000 次 202s
    % Y" l3 P. z2 \% o
    & I, C! D3 U' H1 e- F( Q2 V% a不做内循环 200s
    / _; ]( J& r% ?% t1 a
    % L. j* f8 r( z* P9 n$ o你昨天说的对,内循环本身占比是很小的,大头在其他处理。4 Q- T! j" [. @& ?4 j
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    ! ~" b2 B  N4 v* ?3 |2 F- E* @2 B$ }$ B5 O
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)* W3 @5 u# c0 F6 q- X

    , V+ q. R) j4 l# I(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)4 w$ W5 U8 ~% X9 g  i

    3 U5 U. }! X8 V/ e0 b; V4 T
            std::vector < float > vec1(N);
    . z( [  j4 h* a% e7 ~+ i+ H        std::vector < float > vec2(N);
    . b. l$ T. L# ~        float* b1 = new float[N];6 [. D: N# w: f9 [- T5 S# X1 u, V
            float* b2 = new float[N];7 c4 @& b& m% ?( x9 x/ F
    ( H2 M  }% a* C4 p' _
            for (int j = 0; j < 6000; j++)7 Y& Q* B3 M% }2 N- k
            {) _  v( `/ }8 o1 M  ^
                    std::generate(vec1.begin(), vec1.end(), []() {
    - s' b, N7 {# j# B0 m6 _                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
      Q" |+ x$ |- |/ a9 V0 b! A! D                        });
    $ P/ L, H3 ~' o7 J' L9 U& m/ x$ [4 w; k' P$ o; q# y; [
                    std::generate(vec2.begin(), vec2.end(), []() {% s$ u7 R- ?" M
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;4 s) m( r' p9 J  O
                            });
    3 ]) z) {1 Z' J5 g- Q  O! s- L3 ^. H; v# ?) }- w- t6 X- P
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    : R1 c" q1 k; z$ I: Z$ f0 p                {& H- p; y: B4 ^1 N5 {3 d8 O
                            b1[jj] = vec1[jj];
    4 r/ \" m; K" E$ F                }
    * W4 P- P6 d( o3 O) M% G- d8 ^' `$ w3 N
                    for (size_t jj = 0; jj < vec2.size(); jj++)8 ]) }7 H. Q- _, L# a5 n- `
                    {
    * t, u3 c! O( s$ c' ~                        b2[jj] = vec2[jj];
    ; x$ u; w% n  {                }6 T6 C3 I1 a3 S6 p0 x6 m7 e7 `( P

    7 P* Q7 F( j# {9 I8 E% }- P, _! f4 Z                //Method - 1  N=100000 247s  ( U% k2 k# Y( _, H1 r
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    8 v+ y5 }( }+ H% c0 ]& B; i) v                                
    8 w8 Q/ f% J: e" r( u                //Method - 2  N=100000  237s
    ) k4 s  \  U, |5 S" G$ P& N8 N0 W                /*
    3 ]+ f' z; a; o3 J& V                for (int jj = 0; jj < N ; jj++)
    & j1 ^) J2 Z6 _/ }3 R& r' m8 R                {
    1 b0 a: v' \# V9 h, E2 R                        fresult += vec1[jj] * vec2[jj];
    $ o# h! [% x# T2 O: l( O4 U: n" J# }                }
    6 q* k, n! ^" `; Z$ z0 }, I                */! y  \- }2 K3 B- J* k& y
                                    1 |5 |' C; E. J2 h7 o
                    //Method - 3  N=100000 204s. \5 T8 i: @& i+ t# z
                    /*
    : U$ M6 D0 U: }' I2 M7 i                for (int jj = 0; jj < N; jj++)
    . L$ B# ]' y; r6 k# z" s                {
    : a3 C1 ]1 |% ^/ z                        fresult += b1[jj] * b2[jj];
    ' m5 q4 i% [7 ]0 G, S1 o                }; J, V) a' \! z6 _8 u1 N7 M
                    */
    4 e! P4 Y* m& s) P( h
    % X9 Y  l  a% z+ P+ `. Y                //Method - 4   202s
    & X1 H  F! k; p' m& r# C                /*9 N( g7 a; I" z2 T6 o% B2 T
                    for (int jj = 0; jj < N; jj++)
    ; v0 U6 f4 X- M" i! z5 W" h                {4 l! F! w) _! X3 F# u
                            
    + t# S, A# |3 J' X) n" K# p; K5 _                }
    & W7 J+ \) Y2 |                */  N! }0 ]" `( ?7 _- ~
                    //comment out all methods, N=100000  202s               
    5 [" u: q0 z, y% v6 K& I7 u        }
    4 L% O3 X7 z9 o0 l* B$ Q
    0 E: ]$ W9 g5 w0 G, `# ~0 M% k! _        delete []b1;
    8 I$ Z1 ~6 R2 Q        delete []b2;
    6 U5 x0 w1 k5 }
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?2 X# Y* |% V' I1 Y, n. Y% T

    / |8 j8 C2 ?% u你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?% b, x. x6 S$ N  q! L6 m# P
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15: X" ?* `# x2 M+ \5 ~' T
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?; Z, V$ n, j( X  R9 y

    $ r2 L& a7 s5 a0 y, l& B你第二个试验里面的j在循环里面又重新定义 ...

    . e' w( L5 f( S: }9 U; [" u内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL3 f5 i. |' ?7 ^( U1 ?0 i9 S
    0 N7 ^- I* d. o0 f; T; T
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16. C( M4 b. s1 T$ l
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    2 T2 n# Q+ o% s2 v
    5 q1 B4 {) p/ c0 F$ \% e; ?* U不和它 ...
    ; R# Q( g$ K7 v1 }8 s4 Z- R9 e

    * ?% K2 O0 o4 l) E# w6 ]不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    ( ?& K/ `" T( |( ?$ }后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:540 x; {0 s) F; H: ~/ p
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)9 f5 y3 u' u* n( W+ `! S# C7 q& d
    {
    ( a( b* c% j1 C+ {: E        comp temp, xtimesy;
    / A' p. Y' z+ j5 F; V4 x. f
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    ; K5 R$ [* v3 l1 D内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?4 l# q/ j! R+ u7 K% V
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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