设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?  K# x9 j& g5 n2 n
    5 H7 @1 l/ H# R- o  f4 z
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。7 g  _" p0 @3 i: X$ `* ?4 }, u
    ( |* D$ y+ f- v. ]/ Z3 t
    速度优化问题真的很有意思啊。
    - w: h8 c$ Q. w
    5 d: L4 c3 ^" _) h欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?* E1 [) K: b* s, Z( w
    把代码贴上来看看?
    3 I# b' f. z9 Z, M- T1 t
    " h2 \* N$ l* D- \. t* z3 @难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 ( k1 A; m8 ?9 @( q
    数值分析 发表于 2022-9-24 23:04
    , v$ @3 h2 d' n: g2 k) n2 l2 o% A拉下来?拉多少?0 Y$ a* k0 ~, m; {
    把代码贴上来看看?

    " S4 S5 ~( A% c3 |% z7 L3 g. u% _! F1 D* }/ H5 {' M" t# @8 l
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ( _) [/ q. m2 D: Q) G{
    - n7 E6 L; L! _' k0 W1 R7 Y" T        comp temp, xtimesy;/ ]# K* l3 @" d" b7 A
            xtimesy.re = 0;
      T* J  h9 Z2 Q' d1 x" g        xtimesy.im = 0;
    + B9 F$ J$ q; \, P" {' b8 l( ]( u        int j0 = lenB - 1;- b! c0 u) f, E7 q4 i
            int    i, j, i1, reali;
    0 D' M2 C4 R* W4 Q3 y        if (lenA % 2 == 1)
    . p" Y% E* j; q5 Q5 M, e  f, R                reali = lenA + 1;+ r+ B$ \) P$ n, e: B! S, Y% b4 U
            else
    ' G5 ]. P( ~8 [- E7 L                reali = lenA;
    ( T  L, v7 s8 Y3 \4 L1 U        reali /= 2;
    : C) r# I2 n, n% T( Z9 _# e+ P6 o, i/ z1 p- V
            int nconv = reali + lenB;4 T2 \/ T6 H( u6 q6 @3 w
            //#pragma omp parallel for
    8 X) x+ c+ T. r7 }' j* ~: ]        for (i = reali; i < nconv; i++)2 d2 `! L! Z) K5 y# `
            {( h# q% C; K! b$ }& t8 T, {9 d! t
                    temp.re = 0;
    0 D5 Z& T. G: B! B! Q7 f                temp.im = 0;
    8 S4 |- L, E3 {% ^/ D                i1 = i;/ N! b; g8 l0 \0 ~7 `" E* Y: ]
                    for (j = j0; j >= 0; j--); H2 B) F+ J# ^! P+ Z
                    {; y& }+ o1 s# j( u
                            /* floating date operation */
    4 O" x) n0 R' R# l7 H9 p& n- x                }
    2 i4 D; b$ r8 o) f5 E2 F) m  W
            }
    4 A% a% Z8 i3 r}
    6 O6 c' `. m2 y! f7 i- c. D4 Y7 `6 X
    * h/ P1 ~& `) w$ {. N& Cxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    * c5 z, o* G  t& u4 A- E! t& U
    $ n6 Q9 y, f8 S; ?8 I% q& J) L# Y红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。6 w" a8 [3 b$ f/ H1 N) B( t% |3 r
    现在call xcorr 100次,耗时78s.8 G. E  K0 V* U

    " D1 ?# Q! U3 a( i6 |8 X如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    ' q" m# c% U  T: j1 g) q5 B5 M& I& M( o5 ?; K0 E* U
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:335 z. `. f: q( v$ O1 j9 |) ]- |0 d/ H' K
    Maybe Debug mode?

      n% j: `  M2 r# G* l" \+ P. ~) r0 a* B& r+ Y
    不应该,看我上面的回复。3 @/ j2 f9 g# N4 H$ i
    . x2 F8 z* y: @) ?5 N# t2 j
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 6 z- ~' Y7 P* G. V* v- E
    雷达 发表于 2022-9-24 23:54
    ; x' P) Z' V3 U* yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    1 K; h4 [" q5 V0 ^' l5 @{7 t( g; o$ c; [) h. S$ A4 U( h: l3 z
            comp temp, xtimesy;

      ]$ m/ Y, W  l  ^( `: D5 x2 R3 Z* c8 j- r' L% l
    这个不是这么比的吧。。。
    6 F* w, h' B4 A8 E, l1 s
    ) m3 D" ^6 |7 a8 z$ D7 \您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    , U8 m3 c; A: {5 h
    * q7 e- @$ _( Y! P) f而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    , k* r+ E1 c8 |
    数值分析 发表于 2022-9-25 00:20
    4 i: }8 n. r9 E+ `+ |3 V1 [2 q- o这个不是这么比的吧。。。
    # \) L  x- O% M  Q+ e& Q' `! q$ ~2 B  C- Y# f
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    0 X" s) r0 v7 y: q% G$ B
    5 e1 G4 S4 o1 f. G. l1 `# _# H; z' u有道理。
    " F+ R3 U# a6 Y所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。% t  i/ U! W: P% T: ]+ u6 Z+ q

    ) ?2 N$ d% o# T: d. n+ W我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46  k4 L' U. a  f& v
    有道理。
    9 z! ~! O" A  @, k所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    ! w* J1 G  |2 E( f你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多% i5 ]! t& L, Q$ b
    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 {4 s8 Q. L2 q5 @: _这个不是这么比的吧。。。
    # f% D6 y& f- @5 `! c  e
    % t( j1 g2 u" h5 V您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    - Y# }. ?8 ]1 H  C0 G/ D+ n+ G& u# W  O$ V6 v
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 3 D8 }+ m" E& b" D: e
    沉宝 发表于 2022-9-25 01:48
    . h9 w* c6 l! y: Z' w现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    ' n; j) l) W9 p/ ~- \2 P
    5 Q( R* S  S8 ~4 U3 M  \! @是的,兄台说的对。: D* {' B. X1 |6 {
    7 L+ |- L- ~7 r4 \
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。% ?3 a2 I3 t  w  t  Y

    % T4 ?6 m1 p4 o+ x# g雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    ) Z; }7 E2 s' N
    $ C( N! B  d# f  s比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ; ?: W4 f: {: M" k. j1 w9 H2 _. R0 B. s3 M- k
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    & X; N3 Q1 r. \9 y' R  \
    沉宝 发表于 2022-9-25 01:27
    9 }5 `9 \0 e2 z0 D你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    # n. E6 b5 C# x' A! Q
    8 w3 ~1 L& l+ d8 N/ A8 ]* m
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。+ O: r% P& T; D6 F$ C. w

    7 X2 m$ F5 F+ ^$ F我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47( o' ^6 O3 w& o' V0 v. p
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

      ]  }5 m  K$ I- o! U( j0 I& k时间差一倍的结果可以接受。
    ! H8 @& `" J! a9 o; V' w9 w
    8 ?% d) _% H5 m你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    - d' o; w+ D" c! s. G0 `9 m
    雷达 发表于 2022-9-25 04:47* p& `. c2 U. Q/ l) S8 W) p" N& `
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    8 f+ z' W9 W; ^1 m6 W( D
    " X2 v1 i8 C" F2 U  w9 V
    1 }! w* p9 x( k$ q
    7 z$ B3 v, V" j/ w. r7 e: `能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 4 E' a# J' s8 U
    数值分析 发表于 2022-9-25 14:58) n8 t: \1 `. F+ q% |
    能不能把这个也贴上来,看看和上一个有什么不同?

    4 j6 N4 `% a7 e/ u& p理了理思路,重新做了一个测试。) B6 C0 \( c1 g& _* [
    做了两个 vector 和 两个 float *, 都长 100000
    * O4 J) ~5 o% j4 O/ L5 u外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    ( T  U' ]0 v/ B& c: o/ O- b- o2 @0 k1 T+ z. v
    内循环试了4种方法,2 S3 p3 l  Y+ h/ M
    1. 直接调用 vector inner_product 247s
    3 f  m* m4 k7 W# K9 n, _2. vector 循环点乘累加 237s) `5 ?2 x* z9 n+ z
    3. float * 循环点乘累加 204s
    # J7 F5 m8 p/ G. ~+ R4. 空循环 100000 次 202s
    ' f7 i( e  k1 f
    & J, w* B" x7 J8 O( y不做内循环 200s7 A& b7 U; j0 }' [- B. o, t

    5 {7 i# T% T' Z# D你昨天说的对,内循环本身占比是很小的,大头在其他处理。- u* k9 t, w& b% f3 Z& `$ J
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    ; C1 U: R2 h6 s0 [2 \4 y$ t8 ?5 @( G- G1 X- e
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
      S$ X# e  m$ v" D: {. m, J/ g4 m
    , f. z" S# a$ [' ~(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    8 k; N- ?" K+ l2 M
    " r- n* y, a8 b8 _" X+ r
            std::vector < float > vec1(N);' i. ~# S$ g9 p" a- ^5 U
            std::vector < float > vec2(N);$ [4 g$ e- {" U/ b4 c6 Q, a
            float* b1 = new float[N];
    : Z1 M: X% o# Z7 v! o/ ?5 n        float* b2 = new float[N];
    1 {  a8 E% P+ R, Z
    7 P  F8 x& W* q9 ?5 L; E        for (int j = 0; j < 6000; j++)# R# L  w" y6 F0 s4 [) |9 x; |
            {
    , P/ c/ g5 \% @7 x( a& X0 V                std::generate(vec1.begin(), vec1.end(), []() {7 h  Z" E4 a: n$ p. e0 R+ q$ N
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;5 `, b  ~0 @! ~2 L
                            });" u, h3 U7 m& f7 {( [3 r

    ; w7 }2 U4 C; l( U                std::generate(vec2.begin(), vec2.end(), []() {
    " F; n7 O: @0 t, L: q                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;2 w( C% W; L) {5 h# F
                            });
    ! F6 g: n: j0 i& M5 f( W! h/ x4 @  h
    5 T5 j; L" U/ D" }9 y! L                for (size_t jj = 0; jj < vec1.size(); jj++)) E$ s& T5 s- s/ k7 E
                    {
    ; \2 C) T  l- f5 \  k$ N& Y  \                        b1[jj] = vec1[jj];
    2 r2 M$ }& z7 p2 r6 _  H                }' j- p9 v# ^& m+ M3 k* j. ~8 x

    & |& a  x! h# k6 g3 J7 I! i                for (size_t jj = 0; jj < vec2.size(); jj++)4 y6 s, t  K3 E9 r1 O8 D# `
                    {1 z( S/ d) T( V# U; B
                            b2[jj] = vec2[jj];; S4 B6 d8 L8 ]7 F% T1 {
                    }
    , M4 F$ y' M: M# n0 x# E1 g7 D5 D& f
                    //Method - 1  N=100000 247s  
    0 a/ B: O& Q4 ]2 a# M! @2 Y  J  }& x                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    2 J9 Q8 K' a2 K* C                                1 x5 N4 g: ~) Q5 ~9 Z
                    //Method - 2  N=100000  237s. t. z, i+ B. Q, z
                    /** ~) W& K) `* |0 d
                    for (int jj = 0; jj < N ; jj++)
    9 b/ F+ U' G) X& |  [                {% P* N! ^) L, R% T- R* q
                            fresult += vec1[jj] * vec2[jj];9 G$ J+ w/ |) p! w+ {) t6 H
                    }8 Z& e0 }  U" S( k
                    */: P, S8 H, \' w0 J) @; `: \
                                    
    % l4 ^; g+ `' _& J/ d                //Method - 3  N=100000 204s( t! b5 V" _" d
                    /*" e8 Y* E) e5 J. L% [$ V
                    for (int jj = 0; jj < N; jj++)3 _8 H& r: l. ^
                    {. {% N- _- m  o$ C+ A! y
                            fresult += b1[jj] * b2[jj];( r8 H! @$ N0 R  F
                    }  b) y; B; L8 Q8 v
                    */
    9 V* X" q1 T$ r& }. a
    ) l6 M) z; v9 V- a  _1 J                //Method - 4   202s+ G5 ~9 X7 r" k3 S: a9 D# N/ ?( E
                    /*) v3 h9 k" B" a* h9 z$ S8 D
                    for (int jj = 0; jj < N; jj++)& n8 L$ c' C4 v$ V; i
                    {
    $ v( n4 L  Y7 |- k) [0 R) O                        ! i$ ~/ o, P  v! G6 n
                    }- A- k# w( x5 Q# }$ m) m6 @
                    */  P; O! a& J3 `6 J: T9 ~
                    //comment out all methods, N=100000  202s               
    9 z7 _1 P) B. L( p) Z) T+ K        }% a7 K& @6 I5 W2 @
    / S" {5 R  q$ `3 e9 C1 f8 |
            delete []b1;
    ) p- x  y! f4 q' S        delete []b2;

    / }# X' h) c; z7 l% I" B( ^
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?5 k3 v  A1 P4 }$ X8 z7 w$ Y
    ( F. W& l( \3 S  V1 M
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?# R' F1 u9 c/ c6 _
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15, t9 {$ {/ N" s4 P* _' a% Q) ]
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?* l& d/ R4 [' ]# h3 C
    1 D1 ~- S: y1 _8 r
    你第二个试验里面的j在循环里面又重新定义 ...
    % L$ n# X) \  P5 k2 }7 g4 G3 k9 u4 r
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    $ N$ X( [& p4 k$ R. {! a3 ^- S. ~* P+ i
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16/ ~" ?# G0 N7 k+ }  o
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    ) F* |& ^  C  {% d/ U' U8 A
    # B7 T4 f* R- `不和它 ...
    6 ^* P# y2 w! K% ~6 F) C* ?
    # Y9 |1 ?9 {1 q9 m( B7 I
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    # ~  t7 I$ }( X' s+ W2 A后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54% S7 E% A$ `, N, O7 y, s  ^
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    8 ^. C4 c, ]9 Y" s{
    ; o# l" y* B+ N        comp temp, xtimesy;
    5 p" Y1 G' x8 A* D7 R5 S
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。* I: J; r4 j; t& O6 r$ O
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    5 U* j; l9 n1 ZVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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