设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?; ~! s. Q0 Z1 `8 H, h  |, i: S2 z2 \

      W. e1 s" S+ h% I! Q自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    - v. t: D; Z# i0 F2 C8 Q7 E- Q1 D
    速度优化问题真的很有意思啊。
      W3 g$ z4 }9 l9 D! ]7 ^. |( d, l3 r. i- p% T; _5 f9 i
    欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    % k$ j. T4 ?' J# M8 s% ~: O/ L把代码贴上来看看?, G, R2 D! G& ?% I; p. z6 B# D

    , t( x% `: J! \$ {0 ^难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 2022-9-24 23:15:41 | 只看该作者
    会不会代码本身的缺陷阻止了自动优化?另外,硬件配置和开发环境可能也有关系。
    回复 支持 反对

    使用道具 举报

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

    [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 编辑 % R2 \8 Q" @7 S, t  u
    数值分析 发表于 2022-9-24 23:04
    % X  d) W" w( D拉下来?拉多少?
    ) x& v* l( D) ^, ?; n. N- P把代码贴上来看看?

    + U( y8 c: j. z5 T% U
    ; c$ `# j3 J5 \. C. ^$ M' ivoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
      y# Y, ?2 S6 u{
    3 X9 L1 N- F8 e# h9 k/ N8 `; k        comp temp, xtimesy;' K1 E; D' h) W! X6 U) w4 B
            xtimesy.re = 0;
    5 c7 ]! [9 s& x% F" B        xtimesy.im = 0;9 k1 X8 G. j* D- h) n1 @7 G
            int j0 = lenB - 1;7 b  w+ T4 A: f1 G, Y* `$ a( ~
            int    i, j, i1, reali;
    & R# G, V( d( a  I4 B/ F        if (lenA % 2 == 1); l# u: A6 q7 J
                    reali = lenA + 1;
    . h) `) F* b5 t        else5 i8 _6 R0 S% ?/ ~5 x. ~. z
                    reali = lenA;
      k; v  d' Y; Z8 I( M; N! C        reali /= 2;! b+ }4 ?. t4 ?, J" |6 c  I: k

    + t8 u2 K5 ?8 }" e0 b        int nconv = reali + lenB;4 w3 ?5 R5 J4 I
            //#pragma omp parallel for( D$ x7 v7 e9 ?/ N6 p
            for (i = reali; i < nconv; i++)& |' n# e! v( l
            {
    * S, r% b/ q) m5 o6 _" ~3 U7 ^                temp.re = 0;
    8 s$ j, i, _; m8 Z3 w9 Q2 b                temp.im = 0;& l1 g* Z1 Y# ]
                    i1 = i;
    ) I' g$ Y& G' p                for (j = j0; j >= 0; j--); @) W: }/ B$ \
                    {
    # d  {' @8 [* U" z$ i% H                        /* floating date operation */" ~6 V1 h0 r; b3 }0 D+ A0 \7 \
                    }
    4 P/ h% `* n- c  ~# f8 v, V, L) P
            }
    + r$ v& U2 E. G7 {}
    3 e5 \8 [. S, h# q& K3 z
    * O. X2 ]& `0 N, z( c7 [8 yxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样( y& d/ D) Y( L7 j& h; n

    $ J( P3 o! Q8 M) g- P# l红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    6 H) F3 k  }5 h6 l& `现在call xcorr 100次,耗时78s.$ C4 m$ q1 R8 {. z

    8 D# i# E) t' ], R; T; U; n  z& F如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 7 W9 z9 ~$ ]7 s% `( s& K

    ' @, \% G: f/ I/ Y- X
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    - F, F4 w3 Q! O/ e: hMaybe Debug mode?
    / r% B( q4 |& n

    ( G1 k+ C9 {. b& x不应该,看我上面的回复。! H  i, ?" P- v' o5 `! [

    ) E) [: O" E4 G" H) \1 d我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    * D6 i  Z3 e% f( U
    雷达 发表于 2022-9-24 23:54- K3 W+ T; B# V  e
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    * S, W+ _& n/ p( m5 m8 B* z{
    2 d, D8 B- Y% S        comp temp, xtimesy;

    ) W  \( Q& F, Z9 o, M7 _" p8 [: h! Y! P3 Y0 |' o
    这个不是这么比的吧。。。$ u4 i4 }& W( t1 r# q+ T

    9 D' G) m, u# t/ l您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
      q- ]/ `/ ^, M! [7 j7 B! t; }' ?: {: L! 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 编辑
    7 I9 f& `- K0 R8 j7 W& {" ?
    数值分析 发表于 2022-9-25 00:20+ `' ~. i9 d. h" @3 f" b
    这个不是这么比的吧。。。+ K. H$ b' O4 l9 D$ [
    8 K2 P* k! Q' f) T; Z3 k6 b# }1 |
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ; J$ T+ A' b% i- L5 b* f3 K
    ) m4 G3 x/ n$ Q4 W/ X有道理。+ w2 m  n4 w( Z# H
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    7 n! |) }: h! W) l; `) |7 A
    & C, [4 h( }0 i. f2 O$ w, c我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46: T- u' l2 W: D" }" ]2 W! r6 @* q# g
    有道理。
    # e5 |: ~' J* B: G6 R: U" g4 W所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    % s5 P( K) E4 s0 g) d8 G# ~你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    - l0 D0 Q# k1 x; j/ \+ GWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:208 D3 v) E+ y6 g) }6 ^) L
    这个不是这么比的吧。。。
    ! a7 i" a+ O) f3 L% \/ c0 [2 G" r' R' p2 K/ F! C# [
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    / y. A$ C6 l; J

    9 Y3 f0 \: C! u# Z" o现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    ' ?% j+ p- h: R! z2 b# ~4 ?% {+ u
    沉宝 发表于 2022-9-25 01:48; J4 ]5 I/ E6 x; [  }- |# T7 Y
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    4 [; R% _* s7 d) l  N1 @! o; R& A$ Z

    & p) u6 Q1 @) D' Z( b9 o是的,兄台说的对。
    $ f- o1 g8 m2 y& v  X% g  Q
    : P( C! }. d" N0 [9 P" B5 _( n其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    9 Q9 Q; s% @% J5 g- |; I' a) e$ E* O2 ]
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。2 a, Z& y& H6 ^7 }) F5 c. Q9 V

    . o  \1 w8 {, v8 f: H, @2 |比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。+ a+ D# D$ {5 {  c- v( H/ Z

    . U% P% P' g' d9 W1 d当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    2 p1 D6 Z8 {$ b8 K, W9 Q
    沉宝 发表于 2022-9-25 01:27
    + w( g* l, [- L8 Z" N. ~你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    : Z, d1 k+ V1 F7 \! R0 w

    " [$ u7 F# ~& l+ O又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。& L+ ~9 Q# s8 q: h( ~
    % A$ B- n' [2 b! I' l' q
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:479 W* w7 A& Y" B" e  d" F
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ; b7 u" t) p( k& h0 Q
    时间差一倍的结果可以接受。
    ) U/ z0 o# _# |3 e9 r5 I5 x: S' V! P- p. m! @: [% u$ u( I
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 $ [( J: T2 q! H' j
    雷达 发表于 2022-9-25 04:47  e6 m# `' m5 j" T. I- E! M
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    5 p' b# Z  p) h
    1 {) B/ m4 F9 H" a, ^  P3 Y$ h. ?/ G3 k. v+ H; ?

    9 m' J# B, [' D3 w' X; Q& H3 [能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    8 C- ]1 A! _+ x$ l
    数值分析 发表于 2022-9-25 14:58( r+ H$ o! k8 ^5 {. L; W0 b" i; x
    能不能把这个也贴上来,看看和上一个有什么不同?
    & t* v  ]6 ?7 f# \0 J' V
    理了理思路,重新做了一个测试。
    ' i0 Q: ?5 F+ G, s! v3 y+ B做了两个 vector 和 两个 float *, 都长 100000
    " I! |3 Y& k$ v+ E8 v  v4 q外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    + n' L0 j! q. m( W# G/ z  v& V5 U  q( w
    内循环试了4种方法,
    . ]+ K4 q" r5 F! q; u1. 直接调用 vector inner_product 247s
    - Q" a0 X* f, c- ]3 ~1 o2. vector 循环点乘累加 237s. y! ?  e. L% s
    3. float * 循环点乘累加 204s' |) q0 H1 H4 T9 m. D- M0 p
    4. 空循环 100000 次 202s3 ]$ d, a  C- K$ h
    - H+ G6 [8 P; v5 X( g  p
    不做内循环 200s; r1 R( `) Y) R1 u. b4 ?9 O
    9 y- W7 l8 k# p! R5 J$ z
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。6 s' O5 \6 M! z8 F% z4 m, k2 y7 K; v
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    ' K% E0 l- S- S: o  @, w) {/ p; H8 A9 K! b4 D' ~
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)& L2 E0 ]. Q+ b7 [, P
    " ?1 k! g/ B, `2 T% Q8 W6 R
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    1 `* J  C8 Z$ x! G0 k9 r7 l, J; M% a
            std::vector < float > vec1(N);
    ! }2 q$ o+ W( l        std::vector < float > vec2(N);
    5 Z4 I3 o6 X2 _% W# F+ q" k; x        float* b1 = new float[N];+ l0 S8 v' \) m8 Z7 O( g1 a
            float* b2 = new float[N];
    $ q5 e& T. U; X4 p- u
    1 a5 b2 w- |( b! C& e% B" w        for (int j = 0; j < 6000; j++); m1 _7 J4 L; ]
            {
    , n8 |7 V7 K: T  w                std::generate(vec1.begin(), vec1.end(), []() {( K" a4 i+ _9 \5 E
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    - p& u. f8 r+ t: Q: W7 r( i                        });; W5 n( z: k9 ^% E4 {

    ' e* n- p- G, ^" C: ]                std::generate(vec2.begin(), vec2.end(), []() {
    5 u  V5 v" w/ y                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    0 |1 i' E; q: Z                        });, |" t( _+ V9 O- h9 ?) I
    " Y- ?5 s; j4 u) M3 W0 M& J
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    $ ]2 Z6 X) W- K; m                {
    8 R8 E# D$ ~) v7 a; P$ y1 v+ V                        b1[jj] = vec1[jj];6 A7 A( m) f- T) S
                    }
    / Q- q& M) H- T4 ]! M9 N1 R4 q2 A, i6 q5 I( A
                    for (size_t jj = 0; jj < vec2.size(); jj++)
    9 X1 ^% w+ u7 Q+ a. P' g3 o/ N$ O6 Z                {- D4 d6 \, U8 P. b
                            b2[jj] = vec2[jj];
    ) G: j& D+ c+ I' E) W$ ^                }
    8 P, c4 @! s4 ]7 l: C6 m5 J1 |$ {1 t" u
                    //Method - 1  N=100000 247s  
    ) l% [3 b9 M! T' W5 m                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    2 {! u/ {0 E5 s/ `8 N4 k+ B                                
    $ s9 U4 p# ~. q% m0 Y                //Method - 2  N=100000  237s
    & T# ?1 W' {) B' @% J9 ]! b                /*: K) Q- ^% ^" p5 @% `$ }. G
                    for (int jj = 0; jj < N ; jj++)4 X! c: D) c& W0 M" t
                    {; e8 `( ?8 d" ?
                            fresult += vec1[jj] * vec2[jj];0 w+ O8 H1 E! s: r, Q/ I
                    }# I0 |6 h+ ]$ }% n0 ?
                    *// T/ r+ F+ u1 t4 W  N
                                    
    % K4 S4 h/ V$ n( b$ H( D2 ]                //Method - 3  N=100000 204s/ l2 _' n3 e" v" ~' y1 y- P
                    /*
    6 Z. f, ]( B* h3 y2 H                for (int jj = 0; jj < N; jj++)! _" c0 F! e: S/ Q( {$ Z7 L
                    {
    6 J2 n4 [% w* u& Y" W; G                        fresult += b1[jj] * b2[jj];0 H" N% I& v9 E! R" e
                    }
    5 w3 O+ q. @: I                */
    8 c( z8 E) ^& r" N, t; u
    2 J: C1 `9 \( o. q) l                //Method - 4   202s3 |. C) l* [( B) k* @* W8 g
                    /*
      Q+ H/ @4 t/ u' s+ h7 _( R                for (int jj = 0; jj < N; jj++)
    # e. b5 Q0 h: W9 M7 `                {
    5 Y+ [  p% b# `+ ?2 K+ G' n  w0 E! x1 Y                        
    + w) C* k$ g0 r' f% l                }
    $ u; V6 Y9 m9 A                */+ Q, Y  s9 L9 p0 m) F6 B6 m% {
                    //comment out all methods, N=100000  202s               
    % X/ z, X2 m/ j        }# ~2 V2 P, ~0 i+ {
    # f8 @6 s) b" h1 j. K8 ~5 q/ V
            delete []b1;" L# L  R' o. F, Q
            delete []b2;

    + {* z0 N9 c" q3 V1 z6 r" i
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ) |7 H1 @1 @9 e8 }/ Q. f
    ! S1 r/ [; P& T# _$ G你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    4 M( s: J/ B7 ~" W4 T& v, Y$ Z- u
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    8 D6 O' d/ c4 ?8 y( r瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?5 I* `2 K7 z' [# a; g5 S3 w
    4 k* H9 Q: W' o; ^1 h
    你第二个试验里面的j在循环里面又重新定义 ...
    $ g' V" k$ K( Y3 X+ G
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    / U. G# A1 t% Z  n7 Y2 e: p6 o+ Q" {
    . [! r  S1 h) W不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    " h; i3 }. I. G4 c内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    ' ?7 `0 p4 L. ?# ]- i
    ! Q* d2 x4 S2 L4 s9 i1 w不和它 ...

    6 H0 b; y; B9 g3 i: `3 x& R8 q! k2 w9 k' c2 D; M  d& J
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。# @( {+ |& \" |) k: w+ J0 B% ~9 a& q# y
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    ' V4 q6 C" \0 cvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)& B/ c  _* c5 |6 E" F1 F% b5 M
    {
    3 ]- v6 q8 |/ g        comp temp, xtimesy;

    % K$ N/ Z% h+ w这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    $ F) u) f# ?: k/ D4 \3 b9 S内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    8 Z3 p* B. O! W6 N* G. ?3 WVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-6-14 13:54 , Processed in 0.060872 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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