设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?4 F6 t3 b3 [2 s! W, d
    ( o7 {: Z& B# x; q9 X0 v
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    0 @1 x# `5 q# I# o) f( K/ F' |2 H4 q' b( [! O* D
    速度优化问题真的很有意思啊。* T& E: \+ T6 y

      O( s( v8 F4 ?( ^欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    5 i# j! F9 K( h# g把代码贴上来看看?* B: c. N3 C# G4 D& e) S4 m  [$ V; l. r' h
      G0 e# E6 O, r" _! H3 r5 H
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 + D+ h3 G9 _: W
    数值分析 发表于 2022-9-24 23:04
    , L- Q( e) o  M/ ?/ R7 c" l拉下来?拉多少?2 H5 r6 w" W$ d2 A/ q7 p
    把代码贴上来看看?

    0 A4 r5 S+ C7 C% _% Q; g7 w; m
    + e& Q& Q1 b, q" _% hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)8 d2 j/ f+ q' d4 Y' J
    {
    3 |7 P) c- X/ M  @! B        comp temp, xtimesy;4 I% K8 W# k5 {% H8 j1 V
            xtimesy.re = 0;5 M" E9 u! t1 [4 d
            xtimesy.im = 0;0 O, {/ V6 r/ z4 M. U# ~; g
            int j0 = lenB - 1;" `0 X" b5 o% `# ^1 c# b
            int    i, j, i1, reali;7 U  |8 P4 t5 {. N/ {
            if (lenA % 2 == 1)
    ' x' |( |) f2 _3 e- B: m                reali = lenA + 1;
    % D2 q" l4 o$ B4 v, i$ W  H        else" E& a3 f6 |( `9 |
                    reali = lenA;
    7 |6 s0 E7 R  ]6 g" X* X5 F/ _        reali /= 2;+ }6 y  l8 _1 J

    * t( u+ S% @+ i3 C  |0 |        int nconv = reali + lenB;
    / c8 N- f0 M) C, c2 Y        //#pragma omp parallel for
    " x% o$ k5 x8 Y4 Y- X2 O9 n& R        for (i = reali; i < nconv; i++)
    ! r6 K$ N8 I) Q! S: H3 [- T$ K        {
    8 ]# ?; y5 p# d* d, j6 N                temp.re = 0;
    : O2 B; v9 }% F; Y$ U6 G                temp.im = 0;
    8 u  _' G6 A; M                i1 = i;
    0 x) M: w3 j* ^# j/ S3 `- a                for (j = j0; j >= 0; j--)* ]+ ?3 I" G& P: Y# L
                    {
    ' ?5 M8 a! S; x$ l2 R                        /* floating date operation */
    ) Y4 W* o* l! `# }8 d                }
    ! u9 N1 {7 Q0 R! E, S$ Y8 D) ?& g9 N
            }
    0 \( B- q) T0 T' @}
    ) Y2 c8 |( u) ~0 \9 h$ H0 ^
    4 y: Y- S0 H/ h0 L$ p5 E: S! mxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样! |( u/ l9 b7 e8 x0 o  l
    * t$ K9 ?/ m7 U( G$ }( Z. e% \
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。: p3 K# {  K, z. _: a
    现在call xcorr 100次,耗时78s.
    & y! `9 p' n) A( {4 F+ Q5 _" F4 `6 ]/ ~
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 2 a$ A* U7 B, m

    / F1 b2 C5 k! M9 Y* @
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    ; \( Q8 a* Q1 |* l0 a4 J9 YMaybe Debug mode?
    / @- y! J+ _/ U6 f: V! |; J0 o

    ) m+ p: d$ s* W! |# a$ L不应该,看我上面的回复。
    6 F& W% h0 E! I* C) M1 ?4 g! f7 k/ x  I# q# j
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 ' V+ ?; E- A6 K: D1 H3 W
    雷达 发表于 2022-9-24 23:54
    ; j) k3 ^/ L+ k, _9 avoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ) K5 n" B/ ]6 e. l" W{
    ' D+ A! d6 `" D8 H  I2 Z8 w        comp temp, xtimesy;
    5 J9 _* n# L! K# w7 M$ y
    $ }9 Y  K7 H! n! Z
    这个不是这么比的吧。。。
    # n+ M( w/ e2 o/ q
    ' x7 T  m5 ]$ Q1 s) `1 c9 o# v您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。" s. p  [, A! H$ `% u( w. }2 ^
    % u' U& K+ |5 q
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    ' j/ w: J( }' \# [+ H. w& u
    数值分析 发表于 2022-9-25 00:20
    : N. V/ u+ T4 F! H. W* e: c9 s: Z* |/ X这个不是这么比的吧。。。
    0 H' w$ N( W* Y! N7 N- \% D/ Q% u" j" R/ P
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    # |7 }8 |: ]. c

    * M" u% D# ]4 I8 [+ k. L有道理。) L$ ?" L' x% z* g% `, ?3 K0 D
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    ! n& |  _' b! t4 v3 O" b5 j4 X8 u- {1 t6 a& ^  |$ Q
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    " l; |/ |+ ~: u, f1 H: K1 ]' ]1 H' X有道理。' p) x" _2 G" \% a) f
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    4 Y/ T* @6 ~& q6 [! G8 {% O; g你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多4 \, A, W; Q* [% V+ X
    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
    ; e& C5 s$ l* I- k3 A0 x5 H这个不是这么比的吧。。。
    ; u. o* Q! [9 A1 h1 q, a+ H6 w/ V& g7 |9 g: p
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    ; V$ e( Z( S8 u( k+ a. C, H% S1 {& W6 p4 B
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    0 ^' ^2 }$ D3 I5 g6 P/ _4 D
    沉宝 发表于 2022-9-25 01:487 M: g4 E/ |# f% Z2 x
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

      g. f* D: k2 x
    & `" N$ I: Y3 M3 ?是的,兄台说的对。; C9 {8 \8 F1 a- d- Z' c

    6 f" U" ?  t$ |+ h( b/ d其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。1 g% o7 O2 K& F- t( ]- g( f
      ^- W- `3 o$ a" @/ R
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。" d- ]! y* L, n: G& q# u
    ) j, M  {8 y+ R6 E  r
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。3 H1 B% U  }8 q
      L5 u' @6 y: R% x8 u% {/ n
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 2 h  g3 v& e( x6 f
    沉宝 发表于 2022-9-25 01:279 |: ^  |6 ]( j7 E2 l* H4 |& d' j
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

      F3 {& x6 a  C1 n( N* w! W) k$ K* c$ N9 U
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    0 R9 M! x4 H4 ^& C- Q2 @: p3 R3 _. S& g/ i
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    ! y" o- ~+ m6 t# Q" O+ C) |$ A又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    * \& b5 A5 T! s6 }: o
    时间差一倍的结果可以接受。. {& W+ H4 T) E
    . a. O/ A; o3 F( ?; V  U4 b1 f4 ?
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    1 Q0 U" y4 ^9 _3 s$ S
    雷达 发表于 2022-9-25 04:47
    0 o; ^* J5 {2 c* F: f又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ( H/ U! p: b9 `# y4 s+ g  E% p
    # S7 \+ C. q5 n' c( M( [( B' f* v% b

    # G% p" n5 |' f6 m  J. F9 s$ t能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    # Q! W6 x' c' q; i+ R; K& @- R
    数值分析 发表于 2022-9-25 14:58# c  B; f5 K- K% o) z% v# y3 H
    能不能把这个也贴上来,看看和上一个有什么不同?

    + G9 U0 r3 |: Q* K理了理思路,重新做了一个测试。/ G, y, B$ _' T: A$ M
    做了两个 vector 和 两个 float *, 都长 1000007 F3 t# ]' _) l+ O
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    + R8 f& `6 _0 d5 v% r7 [2 T. o
    - s9 U" c) k- R6 q内循环试了4种方法,
    " O. v, U5 c+ p: Y! ?- r1. 直接调用 vector inner_product 247s ( Z0 Z+ l" @' _* G% F
    2. vector 循环点乘累加 237s. C5 q6 u/ Y( e
    3. float * 循环点乘累加 204s5 v* s, {# F! _# w, h
    4. 空循环 100000 次 202s3 }% W2 @4 v( X* j8 _6 _! s* a* u8 P

    $ ?# s& h2 w, a$ y7 K$ }不做内循环 200s5 W) `' q  d$ {) W1 b2 n$ Z2 g) h

    . n6 \7 b* O( }. r你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    , [5 [" t4 `; h+ r7 K另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    . i* C* \" n% l4 v
    2 x4 M, W  T7 m# o/ c2 C至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)1 G6 F$ M: X+ C, @0 m/ q  _& p9 Q
    8 ?8 I1 `" P' l8 [. v: L
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)  n2 @1 O* A0 p; f
    . {. K/ z) a* }
            std::vector < float > vec1(N);
    5 O- b. i4 C) f+ Q0 w& t        std::vector < float > vec2(N);$ G+ [7 a7 @* d; a# @; I
            float* b1 = new float[N];3 {$ V% s; B: W# u/ A5 ^9 h
            float* b2 = new float[N];
    # E6 U( c4 t8 T7 d6 @" I. P& M  r. ~9 h* o9 s2 A# C
            for (int j = 0; j < 6000; j++)
    0 o+ b0 d# ?# y$ j, x/ Q        {1 Y" a' g2 S' t! C( r
                    std::generate(vec1.begin(), vec1.end(), []() {
    ! ]8 `) U" ~% m                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ; e! N" t6 t2 v: i* [" M0 Y6 h% P                        });+ L- Q5 D0 n+ z3 j7 T  w
    : b* u; H% }5 O& r4 C
                    std::generate(vec2.begin(), vec2.end(), []() {3 n: ^  w$ B- W" C
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;3 q! w' B& @) S: {9 [/ I8 s2 c
                            });
    ! W# H; j" h2 g. n/ _$ N$ v( E
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    ) d2 U9 Q! Y# e+ q( c                {
    : o4 I, {" k; ?' q                        b1[jj] = vec1[jj];0 a( O3 {7 E; E# ~/ j7 Z
                    }; M  y7 R9 T8 _  d- e2 Q1 ^: y

    4 P" V& _; r% Q9 c* \" I                for (size_t jj = 0; jj < vec2.size(); jj++)
    / J( ?9 g+ x3 A+ n* i& b                {) h/ N3 g% U- F8 E, v& }
                            b2[jj] = vec2[jj];6 Y; H* P- W& L- C' T* w& w
                    }- D) Y& A; B2 u
    5 S6 F8 V" c. p: B& _
                    //Method - 1  N=100000 247s  7 S& n" N# p" I3 X+ Z) F1 Z. T
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    % z& I& s" g3 ~                                
    4 g% ~) J7 L, s. k. l' x                //Method - 2  N=100000  237s
    8 @, a: s! \: S. W+ i8 v' ?( y6 E                /*! b+ c" S) r% j. q- {
                    for (int jj = 0; jj < N ; jj++)
    8 p2 j4 s$ d6 j* j8 k  M4 Q% t                {2 G' O. P: d" ~1 I$ S. B* A9 v
                            fresult += vec1[jj] * vec2[jj];
    + w* E; X/ g5 r                }
    ' L& c& E" B2 v6 N- Y                */( S$ Q$ y+ V; @5 a
                                      A3 P3 p0 N* z2 t
                    //Method - 3  N=100000 204s# E2 y- u) \+ d! Q. A  P6 ]  L* O
                    /*
    1 M) ~" N5 z# T7 |, M% C! g; N                for (int jj = 0; jj < N; jj++)5 t' g  F4 ]( X/ d" P' k& {
                    {
    ; W& o" ]5 R$ n, U! `  l" a                        fresult += b1[jj] * b2[jj];1 \2 N( u' s( R7 K7 L; G% L1 w# _
                    }) {8 q# K$ z4 H& W2 I
                    */1 Q+ H6 B" w: }% `  u4 y  s" d6 A

    $ A6 {3 n; Z; N/ W1 W# ^, E                //Method - 4   202s
    + X) s% s: e. Z                /*
    1 A& I* v" y5 F) {1 \* }                for (int jj = 0; jj < N; jj++)" j. |( C: t3 P+ ^# P+ q
                    {2 V- o3 N3 q) Q) m1 U/ L/ G, ^
                            + n9 O: [9 h5 C+ P5 L$ y1 U8 F4 N* h
                    }
    + ], B- e6 ]4 R# O) o                */
    : U0 P; b6 |0 ], `7 A) t' j                //comment out all methods, N=100000  202s               
    8 z+ O9 T2 H/ n' g0 }        }
    & {9 D) ]+ G) s& }7 o! B+ T. e0 f% S8 s- U$ l  o
            delete []b1;
    7 W. J" g: q* `9 t% |- O        delete []b2;

      |  B/ T" C3 O
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    0 G: y0 }( g) C6 P- H/ y: L
    4 V( X/ }6 ?7 B( @你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?! U& r7 Z4 o8 k) e
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    % {' J  O: a: d* o: d/ i% @瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    2 F: P3 k- _, v; y1 V
    # r7 ?( Z) _# d7 _你第二个试验里面的j在循环里面又重新定义 ...

    9 x2 m3 `- W  C) q- ~/ ^, o6 k4 T! t: W7 t内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL7 K* U9 U' z8 i# ~6 F/ n
    ) j9 [# K0 g' F
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ' r7 }( I1 Z4 Z. C内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL0 {# Q7 @; j2 O2 g/ l

    # S% p( g7 m; j$ J/ c" d9 G4 p; r不和它 ...
    * U# }$ ]2 F' ^9 K4 W0 V" R9 H
    * \& [6 N3 P, c9 d
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。6 }/ P& z) M6 Y
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    : ], ?; |3 h/ X$ |  B5 Gvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB); \/ l2 j, }* y* i
    {
    8 l+ M7 V& X# N9 c9 i        comp temp, xtimesy;
    4 B  ~+ S: a6 w7 Y4 z* N' O) H. {
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    ( u  Y/ S. @- U% B; ~& f内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    + m1 k& c) e2 a* `) ZVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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