设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    " S. n! Q5 C- Q4 v' R5 y: M# p# ?( e7 _; {/ b: ~* G: G
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。6 l/ @5 ~$ r; b$ [$ [  |

    6 Y1 {/ W0 H6 b# i8 a% A; _- T速度优化问题真的很有意思啊。
    2 _. Y  n; U; Q! i% s9 W9 `6 B* v) S* K+ I5 e; m% h/ S, _# _
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    8 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    ) I4 K) G7 A5 D& h把代码贴上来看看?
    & V/ ^8 p3 v4 s/ v) M1 e+ f  }) }$ W# v
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 % n, h2 y) `" C; P
    数值分析 发表于 2022-9-24 23:04( v" t7 K9 H$ Q  e
    拉下来?拉多少?4 f- p- ]1 f% Q1 ]
    把代码贴上来看看?

    * f' X9 |4 C0 p% B( n3 V
    / C' j9 z1 }8 Hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    1 |  D" S9 Z  s: H: ?{1 L" `0 K( b4 p
            comp temp, xtimesy;
    7 E5 ~) b0 j2 {: w" D' i8 r" O        xtimesy.re = 0;
    2 H. b! A/ z8 H. M3 M        xtimesy.im = 0;
    9 y0 N1 S, c5 x' c1 A& Y9 o8 c: C        int j0 = lenB - 1;
    7 @( Z) w  Z/ s& k        int    i, j, i1, reali;
    # s$ x  H( _( }$ o        if (lenA % 2 == 1)  _; x0 B! ]& u3 N: B1 j' g6 K
                    reali = lenA + 1;- k8 O& `. t5 N2 R
            else" N" j" ~. y( I
                    reali = lenA;9 Y3 h1 K, [/ d! E$ W3 r
            reali /= 2;
    3 Z2 r9 y+ q4 M
    ( @$ d; e; B' _5 d4 U% k. [        int nconv = reali + lenB;
    ! u* K2 V6 ~) F: I5 i0 J( L9 j        //#pragma omp parallel for
    & W( F1 P: o: a& G( u& A( ?        for (i = reali; i < nconv; i++)
    2 f0 O% q7 K/ \; [8 i        {4 h- E) F9 ~( L- j
                    temp.re = 0;
    9 v5 J( g1 b9 Q; ?                temp.im = 0;. B; ~% B9 ]3 u8 U9 k0 a$ F) Z% [* z
                    i1 = i;4 P7 Y. a& y% q) G8 h" ^
                    for (j = j0; j >= 0; j--)
    ! o# d7 X+ u- G& ~% c' C                {
    5 i# ?' C8 R: I4 `3 q" I2 |                        /* floating date operation */
    ) B0 E. H; c& B2 P                }

    8 ~. T7 u+ y. z( |8 m- }4 |. L        }
    ! J2 n- B8 `+ W}& o, K& u0 K0 j8 T& t+ [5 ?6 E

    + [& B' c) a8 {8 e8 ]4 vxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样4 C3 D- z* u: P, Q: [! _; m5 v

    + S; T) z1 b2 }7 m红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。) c/ g, t- C1 F4 p/ w0 t% T6 |
    现在call xcorr 100次,耗时78s.
    & g7 Q& L+ n) Y$ E
    ) u6 d7 B9 G/ i3 L! H; ^如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
      B/ E) k4 c, [! L# b5 a) y' }
    $ U& U/ e9 j) n" Z% v9 c
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    ; l0 i8 y8 u) u4 u1 F7 \Maybe Debug mode?
    4 [! Q* \+ u3 L- s3 {# k9 V

    " @$ e# }, e8 E% w  l- T8 n5 a不应该,看我上面的回复。
    , q" ^! a2 a9 W1 Y1 m" Z
    & p4 ~! @: h/ t我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    8 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    % z2 q, }/ W' I  ?
    雷达 发表于 2022-9-24 23:54# A4 c& U- h( J- _' n6 x  [
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    * X0 V! @, |. h' _+ w/ _{' K3 _- F) l- _; [
            comp temp, xtimesy;
    , J1 S$ m- v# \, u( @

    $ `4 [4 {( P4 W  T这个不是这么比的吧。。。
    ; [/ Z: z  d+ _' {- D8 I, q
    2 }: B" l/ Q7 {7 @' n您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    6 t' D7 _  J- y3 d! B+ H7 }! F' V* M7 X; @) [( |
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    2 H) ]  C: ]+ ]# V
    数值分析 发表于 2022-9-25 00:20
    % g. O. G0 W/ ~9 o0 y这个不是这么比的吧。。。
    8 F; j3 q! N" P) Z8 }/ I& K5 Z
    , ]/ L0 ~) K7 w+ i您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    * p' y2 m  p+ W5 z) r, {, B% c$ t/ m9 o
    有道理。9 P4 V, {. C" i) I( S
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    0 d' n/ b+ R& \! f+ X2 `; ^" y- W# i2 W. D# S& d5 o2 f
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:462 V4 d" g9 R% j3 b; J
    有道理。5 y% L9 r* K- r) h! j
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    + O0 U9 b, J* {& H
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多' F* _% L( ^% `1 s% R% d; 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
    * _; `" ^- J0 n# _8 _这个不是这么比的吧。。。# J- f) b2 p6 h; f

    6 F% G; A! F& _# X) R3 Y您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    5 C& V# a' N8 [$ K3 a& Z

    / {1 G' M% O4 q* [; Q现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    8 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    3 L' L: V3 }+ l) ^! ^& x" J- s3 m! r
    沉宝 发表于 2022-9-25 01:48) ~2 ^7 @/ |# V1 _
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    / ]8 k$ ]0 ^/ ]2 A7 s# E: L& Q
    7 M1 U4 `% Y* ?
    是的,兄台说的对。+ |, @3 D! m# J
    , B4 G6 G% \3 U3 q
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    / L1 b! Z6 i/ o/ ]& C5 e, M9 W4 O$ ?- J- m
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。! x8 R5 f: J2 A! Q+ S/ D; S: O" L; ~" J

    * s" P7 M& C( K; G, \比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    1 [6 z7 ?' D5 {
    . a2 H, i0 P/ p/ T& C, [1 b* E1 X当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 . I& w: V( b" F- w& F: Y& Y
    沉宝 发表于 2022-9-25 01:27! n9 X& [1 E. D. O
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    % g# n9 G/ o( Y: z. `& J" S
    5 X3 Y) _1 ~2 D6 e/ N- M) T" \又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    # E* P5 F* ?4 e2 a+ V/ D& B
      d; C# S# Z" E1 J* U6 G: T我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
      C0 l( I" @1 [% b5 x) ^/ R又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    1 H" z1 o- j  k+ `4 q时间差一倍的结果可以接受。
      [' K# [; m. }; r, J  P( N* L( e: I4 A( h0 u( I9 j' N, P
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    8 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 " [4 A! @$ \7 @3 B$ j( ^: K
    雷达 发表于 2022-9-25 04:474 b7 U! I  ~! S& b
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    & D: O% \( C2 F5 R1 f7 }
    ; B$ I6 Q8 Z1 p9 U$ ?+ c6 f& X: ]1 o2 E

    & `# t  H* \& K+ a$ h8 L6 }) q7 p能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 ) x1 w7 s, P. n
    数值分析 发表于 2022-9-25 14:58, ^* w- P' x! s6 N# Y# a; z* V
    能不能把这个也贴上来,看看和上一个有什么不同?
    ' Z) _2 D8 Y* x  t1 r
    理了理思路,重新做了一个测试。
    : ^0 J2 R( ]! p9 A5 w$ A做了两个 vector 和 两个 float *, 都长 100000
    . A5 t) a0 p5 B# C外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    * g( ~( u2 E: ^$ n  ]# |! w+ A- i, c$ ^& X% P+ q6 A; U
    内循环试了4种方法," |/ V( T# X2 T/ m
    1. 直接调用 vector inner_product 247s % S( Y9 M/ {7 y9 S9 ]
    2. vector 循环点乘累加 237s
    . l4 t3 h% C& N3. float * 循环点乘累加 204s
    8 F9 B* O( C% G4. 空循环 100000 次 202s' W2 F4 a# E1 M9 t/ Y8 D

    1 p4 A' Z. b3 e& V0 w. V$ W' G% W不做内循环 200s& |. a. V( k  y6 J7 E

    - g- q; n( U: J% V& A你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    # {7 ~# r& [% `另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    + ]* q" D* d/ j2 L! w* t) ~' ^; W, z, z7 v9 Z) t2 Z: |
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    " m& S, J. x2 F# m" {! X5 e+ n9 s, A
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    8 ?' R/ K6 g! j4 K8 p
    ; T) c8 x! E1 C8 o& q' N" s
            std::vector < float > vec1(N);
    9 F2 G3 M2 r( C; @6 r* ^        std::vector < float > vec2(N);% z' b' o8 h3 f9 V% C$ \! s4 O
            float* b1 = new float[N];
      s2 x3 j5 L! N. X        float* b2 = new float[N];! G  c6 ^8 ?" k) r3 z
    ; F$ r7 P' e4 f
            for (int j = 0; j < 6000; j++)* ]) k" u, Z8 r( ]8 m( x: B7 J5 A$ R( c
            {) M% o$ m3 _/ l  O: I* k
                    std::generate(vec1.begin(), vec1.end(), []() {: ]. L" l* Q6 M% Z
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;; _9 u6 A( L* y" i
                            });+ x6 D& ^; n/ x6 A0 }

    6 ?  w  i9 q7 `" z! b1 D                std::generate(vec2.begin(), vec2.end(), []() {( X4 [$ j3 @# g5 p* l* H
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    0 v, w$ e$ [7 j                        });
    * p7 ?. l$ b3 v) G0 t# h
    ! {* H( r8 j. I, T9 k/ |                for (size_t jj = 0; jj < vec1.size(); jj++)
    / }8 }' i3 W9 Y5 `. b, q' {                {
      ?' z* c) v) q$ n8 o% j8 H                        b1[jj] = vec1[jj];
    ' @- a3 \1 R# t. f. K8 y1 i7 a                }
    " v$ @! q9 ?+ j5 D% x
    * ^; {' ^5 j* s7 X                for (size_t jj = 0; jj < vec2.size(); jj++)* m3 z& {. i6 ?* w7 j
                    {6 `5 @1 C  [  j( {
                            b2[jj] = vec2[jj];
    ( B2 }" q( U, c9 k0 h) G/ k                }, P6 [) ~/ i& @, W5 p0 F5 w2 H2 i$ W

    4 Y; k5 k7 [% y3 p. u. h                //Method - 1  N=100000 247s  
    0 K9 y/ T# v  ?                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    5 s2 J. J0 W. y( t/ k                                
    8 B0 ]0 H* ^7 o6 Y2 \) ]% F! x% X                //Method - 2  N=100000  237s) t9 q$ z3 H2 B; M4 [
                    /*' F& L" I8 Z9 l" M6 F5 u. n
                    for (int jj = 0; jj < N ; jj++)) s; o: [% ^! M  a
                    {8 m# c' G% }$ H$ g
                            fresult += vec1[jj] * vec2[jj];; \+ k& [3 ^+ E% i5 S
                    }+ F1 Q/ ]; K& l, F2 j+ w
                    */
    9 z: |9 K6 |/ v2 v% U. ]! f                                
    + ]# z6 H0 S+ |* _% s                //Method - 3  N=100000 204s2 g8 K& P' u  H- I6 ?7 _0 n
                    /*: i, L) s& n0 N7 x2 ^
                    for (int jj = 0; jj < N; jj++); }) v2 q4 U9 i3 y
                    {2 N( ^' _# t8 ^9 o% n4 M7 D
                            fresult += b1[jj] * b2[jj];+ m  }& [$ N/ ~
                    }
    - y- z% G7 D& j9 w% o  P                */
    0 ~9 k- m# |5 R7 c( l
    7 F' ?% C! l2 F' X, k1 [                //Method - 4   202s
    ) z% ~& X$ s* a                /*) c& M/ l+ t0 G* {4 N9 D) \
                    for (int jj = 0; jj < N; jj++)
    5 Z% O7 Z8 G# k0 B                {
    0 i1 R2 W# R5 F/ j3 H( ?                        
    / _2 @5 f  z2 O0 j& u; k( c$ \                }0 r0 E9 O' k0 ]1 X1 v& t+ f1 c
                    */1 ~( ^, ?( A# r) @7 B; {
                    //comment out all methods, N=100000  202s                6 m8 \9 p) y: e  g- A' Z8 v
            }
    5 V3 B% e  f8 i) e  l- `. _
    ! S) A9 h4 V/ [6 ^        delete []b1;% `3 v  Q9 M1 g' r
            delete []b2;

    : x# K1 U2 Z7 `6 T9 w3 o8 f7 p
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?8 ?" X, k1 y1 `+ s' W+ I( q

      x9 o+ {( c+ A你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    : K" t  [0 F3 P' t1 Q! Z9 r( O
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    4 U5 D/ K0 V6 a瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ' z* T% d0 _0 m7 |: L! Y! V1 L3 i8 e/ |5 Z, v' O
    你第二个试验里面的j在循环里面又重新定义 ...
    / t: I% ^! m* e7 j
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL* B& P3 S/ H4 h* ~! r4 J; A
    % ~5 `! ]# E! u9 W
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    * T& Y* z$ Y3 `% E( g$ A3 y内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL$ @8 u0 K7 `1 H& C0 A
    . p, r. c- B. ^; A/ C( `; W: T
    不和它 ...

    ) F  F6 k6 q6 t( ~, z% b- y. l/ I, f# D8 l3 m3 {6 F
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    , ~7 M% S  U1 j1 s$ U, v后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    % q4 _7 M/ l& E$ E7 y9 z- |7 `6 {void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    & W2 j3 l5 ?- i! l{
    4 k- {  \1 m: _        comp temp, xtimesy;
    & y4 a& {# L9 X3 O
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。. r6 }# x; d( a
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    1 W1 z$ ]8 B+ A" ]4 l, D+ b; E$ UVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-4-27 08:29 , Processed in 0.044615 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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