设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    8 B& F! D' w4 g# ]; n- v
      z, e3 I; w- |& W5 t自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。/ t! M0 ~1 Y3 i: J8 z

    . d0 w  D/ |2 A% u$ P速度优化问题真的很有意思啊。
    # C" Y3 i4 @0 l2 m, t
    4 C2 V7 q1 A, {$ }: R欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    昨天 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    2 D" m9 Z: R0 u* x2 w! H把代码贴上来看看?
    7 i. S, y, f' A! K, }1 x7 u8 C
    : g% b, s; l$ Q2 P难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2025-6-14 10:13
  • 签到天数: 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 编辑 & u& }/ Z, X: B/ Z7 \7 y
    数值分析 发表于 2022-9-24 23:04
    & ]! G' X- P/ @9 |: x- J拉下来?拉多少?$ J& v5 _$ y* d9 ?
    把代码贴上来看看?
    4 Q+ U# Y& `7 }/ [  Y

    7 `. h; s& v* V) lvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    5 ^7 B# u5 p) S! n1 a{/ {+ l% e8 Q) j9 J8 w4 n
            comp temp, xtimesy;% j5 [% q0 }- A( ^0 m+ e
            xtimesy.re = 0;& X/ R0 k3 i- o
            xtimesy.im = 0;
    " t$ e6 {! k9 ^        int j0 = lenB - 1;) f8 [- u3 g" x& V/ @
            int    i, j, i1, reali;
    : |: r- N. L& Q        if (lenA % 2 == 1)4 h6 A* S/ m! V) B4 |
                    reali = lenA + 1;
    3 N7 p2 I6 P; Z9 a        else" Y; {) Z/ b! i7 f0 u5 A
                    reali = lenA;7 r0 [8 Q4 \) M4 v7 @
            reali /= 2;
    & l0 n9 p/ m( [+ j9 ~. Y
    6 L. \, |1 H1 ~: q        int nconv = reali + lenB;
    ) P/ n# I! V( n2 T) x- |9 x        //#pragma omp parallel for
    + `3 N8 {4 a; t' l4 A; b6 `+ v1 [        for (i = reali; i < nconv; i++)7 p: v# _( ^, ~1 a, a1 e
            {7 k+ [# v8 C8 [  x7 r% R6 B/ E
                    temp.re = 0;
      J( F9 ?* u. U( D' Y7 F) e5 k) X9 s                temp.im = 0;( N" k1 b+ M9 g: T
                    i1 = i;6 C( N1 O2 @, Y, J5 i* Y5 X" x
                    for (j = j0; j >= 0; j--)
    : b- S% j" |8 o/ V: E; C- f                {
    2 G! b+ n4 `3 V, D* z6 d                        /* floating date operation */
    2 ~1 [: m; p6 f' s                }

    ' _+ U. e, J# R2 i; I8 ^        }. Q9 P- w, [( ^# Y
    }
    6 C: j5 s' Z1 Z8 s, E# o+ m
    " q% j* N: i/ {5 C5 V* W; L6 f2 pxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    / z8 b& m) ?. E/ l) [# c" }: F/ i, A8 Y; w# u) [1 U
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。+ G0 E/ {' v. B0 E  {; z
    现在call xcorr 100次,耗时78s.
    2 ?- B4 y3 t/ L3 N4 Z. k2 J2 G2 y) |8 L# O, W+ |
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. . k  L( D: Z7 o, R7 i! F

    . a# x! ~; @  i
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    ' E2 f# E. W5 s$ z1 n4 AMaybe Debug mode?
      Z8 b9 K4 C% C3 x! N9 c5 b
    ( I8 k8 a" `  {2 J
    不应该,看我上面的回复。
    5 |7 s- L3 M, F3 K
    $ D9 X; ~: M  `4 r; I: P我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    昨天 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 % ^8 ]+ k; q3 v% _) l
    雷达 发表于 2022-9-24 23:54( C3 J- m2 [# B' Q" x
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)- b) g6 N, K2 p2 \8 s8 B# b% D) U
    {
    * Q: W4 z$ G9 J5 H: l$ f        comp temp, xtimesy;
    : ]/ I2 A6 z8 H9 {* t

    % M4 p" [4 K; j8 |# d0 |这个不是这么比的吧。。。
    ; `/ r( a, o$ ~
    ' s2 c( v+ l6 j1 X' _% C您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。  k- z  Q8 F4 K) n: `& w4 \! h) [

    ; z2 ~! I9 c1 k而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    $ r6 P! y. d& Y2 W
    数值分析 发表于 2022-9-25 00:20+ Q/ A% U3 |- C' n& V
    这个不是这么比的吧。。。4 y+ i/ y( }; G1 b2 n

    # ]- w3 x- H) _) `您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

      @  V& @, M5 N( R7 \+ b: \7 e: ~  S" k' n
    有道理。
    ' g' A) [+ U( j# s2 N. T所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。4 ~8 P2 x  }7 Q
    ) z' \/ ?7 Q! E" i* q
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:461 d3 f4 m7 s" W: |' `- ]* T* g6 O
    有道理。* _1 E' _* U6 u( {5 w& y
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    " R1 H+ o) k2 B' s4 P你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多2 z$ g+ Q2 ^! ?& 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:202 T" P1 W* r! k
    这个不是这么比的吧。。。
    1 o! O- U+ s9 B, q) z, ?$ k+ [1 X7 J- r/ [0 S* T9 o" r$ @
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    4 z2 _0 K. u: Y, e6 f& b
    0 h- d- F$ w) X/ E5 ^+ j3 [% |: B
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    昨天 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    3 \: n) t& T' [  @1 W* w
    沉宝 发表于 2022-9-25 01:489 o# P. X$ L+ j
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    8 {1 c. E4 G0 j$ Z! l7 e  C
    $ ?, G; Q! B+ }6 m: T  p
    是的,兄台说的对。
    9 U7 H9 J2 X0 n# i* {( Y$ ?$ i. `5 a
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    3 Z9 l6 {% u% m+ _
    6 f$ [: V% q* B/ X. z2 B8 k) S雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    5 h, Y: r1 N$ Q4 k9 ~1 y' u
    7 f9 n# F- ^6 \; Z3 C比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    : ]! k7 i" {3 y* x8 d  {6 D5 T& D& \- @! A8 D. ~+ l
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    ) L2 K4 n' J2 v. V
    沉宝 发表于 2022-9-25 01:27
    2 R- }1 |" \- p9 j- P你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    + `( A5 J3 U. Z8 C: s. v
    1 F3 v& Q3 i# z: r8 D
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    " }* P9 P* W0 X. r% _$ m  Z, r
    9 t( a! y9 q9 l' g4 [" f5 @& u: F我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    * x" T9 q- H8 L7 F; t又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    : `  ^% L, l* m* ^9 F+ W时间差一倍的结果可以接受。
    8 U, d* ]; A( U- U/ s9 j9 d  i
    5 _. }' [" _3 k. k4 B, w你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    昨天 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    - l; X+ e! G' \0 w* _8 w* N. ]
    雷达 发表于 2022-9-25 04:47* P) ^8 i  K6 I1 j
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    0 o+ G2 }& e3 ~1 U& i. {
    / S$ L0 j; c/ j# u( G1 O- ]1 _9 E
    . m+ G$ W' O/ S9 n' g& a$ A' s$ o* k
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 # d" J# x+ g. `
    数值分析 发表于 2022-9-25 14:588 Q4 M* ?6 ~$ R# p4 z$ Y1 k
    能不能把这个也贴上来,看看和上一个有什么不同?

    % c2 @" z1 @" j! f理了理思路,重新做了一个测试。1 M4 I, _; i! F
    做了两个 vector 和 两个 float *, 都长 100000+ G. s5 T0 k, D2 [
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    0 [- E0 s& Q- O3 ?
    5 o& e0 N2 D- b% O2 u. B4 N! ?内循环试了4种方法,( v" b/ u# s% E' m- n
    1. 直接调用 vector inner_product 247s
    ( s* ^! S% X- z3 |3 I! k4 S& M8 k; y; w; w2. vector 循环点乘累加 237s
    : @  n! {8 z% T" I  Z) T3. float * 循环点乘累加 204s
    ' m; p* ^" |4 f9 P, i) {/ L4 t# w4. 空循环 100000 次 202s
    ; p0 N: b7 F/ k5 G' a6 i4 w! p) o( I2 ^7 {
    不做内循环 200s7 @# b4 n4 C' m' n9 ~, l& U: l* G" K
    4 _8 |+ N0 P5 {; T
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。* M5 k# M% [' M, |- J
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。7 D0 @- X* Z: S. V* c

    . ^' S& c* e) E5 ?至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    % ^3 }  Z; N# J4 a( q1 w5 F- ?% n7 j8 l0 m
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)9 D5 P5 N  Z+ p) c3 i7 N

    * ^% h2 y4 i0 B
            std::vector < float > vec1(N);; f, f5 T% n7 V9 J: G' ]
            std::vector < float > vec2(N);. H: B& N$ n4 z: U. H
            float* b1 = new float[N];
    5 o4 x/ c. l3 x  |8 L0 v8 N        float* b2 = new float[N];! y2 K* y8 M& O) I
    ( }) W/ ~8 l$ F6 x( x; y
            for (int j = 0; j < 6000; j++)
    * X4 ~8 _, c: X! M3 ^        {
    " C% W+ _* Y$ S- R# r                std::generate(vec1.begin(), vec1.end(), []() {
      k3 N* M+ {2 @5 o1 r: w                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ! Y* T8 b' ^, d! T8 @; h                        });
    $ W# R- `( `) l0 v( ~% }
    ! f5 |7 B4 k% \                std::generate(vec2.begin(), vec2.end(), []() {+ ~0 {" W5 w. ~+ H% ?! f
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    # F. m  z! Z8 _1 b: E                        });
    # p) ]9 {% t  B" H1 a5 T' K( ]4 r5 y) `& r1 ~
                    for (size_t jj = 0; jj < vec1.size(); jj++)8 z" v+ H( b% E+ @
                    {  _9 W# A: A* I8 Z
                            b1[jj] = vec1[jj];
    4 W7 a8 m: J. j0 I                }7 ~5 P7 O) d4 f6 \/ G& r

    - t- R# H- n# K                for (size_t jj = 0; jj < vec2.size(); jj++)( a( ^6 \" Q( D5 A% X! A
                    {( E% f, \' [+ }, p8 }6 J, c0 ?. I
                            b2[jj] = vec2[jj];" }: A3 P$ a2 Y$ k7 Z5 o% `
                    }
    1 W& s: o" }, i0 {" ^6 R
    1 J. W5 i5 s" p. z2 p0 |% l                //Method - 1  N=100000 247s  
    ; I, v* p. |' \% r% B                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);) A) ~% o* W% o" L  X  W% X1 a
                                    7 @; o9 h, a) G: G. `% A6 n
                    //Method - 2  N=100000  237s
    / O# N, V' U. I! m" h, P                /*3 e$ Q6 Q9 j1 j" q/ `. R$ Q# a6 m8 U
                    for (int jj = 0; jj < N ; jj++)
    6 h/ P7 ]' s: u' f) x/ I                {
    7 N/ |0 ?  X& c+ x* a                        fresult += vec1[jj] * vec2[jj];) W3 n7 N' |( W; m6 Y$ P/ E
                    }
    & E# F4 ?) M& e# s1 A* N                */7 h# H3 R9 g9 ]) i! a) K5 {2 W
                                    4 U. t2 C8 C' S5 p6 p0 _0 B
                    //Method - 3  N=100000 204s& O: g! X4 |, w9 q- B
                    /*
    ' D: f6 S$ f2 |0 e0 E4 _# R3 R                for (int jj = 0; jj < N; jj++)2 J8 l# }7 e" E5 p
                    {
    4 Z$ a  T: s+ P% C* W                        fresult += b1[jj] * b2[jj];
    + m% L: D- Y1 G) q7 k$ e0 y                }* g0 i& d8 T- r. g" _2 |
                    */
    + D0 I1 l" X% E' l9 C4 a/ J' d, c
    8 k* K4 L# s: h8 g5 j                //Method - 4   202s4 D9 a8 S8 C% F4 U$ c; L, A4 w
                    /*
    5 L. J8 V3 a; q9 `4 S  ?  m; N                for (int jj = 0; jj < N; jj++)
    $ A) I' f3 B+ l" Y+ B, t                {' L" h! ?# ^0 u$ j# o$ Z
                            ! K2 y8 R* H9 W0 e5 [
                    }- p7 T9 R& b# u1 i$ q! p
                    */4 R- B; `$ w9 e" W' C, t; K
                    //comment out all methods, N=100000  202s                6 F3 @" K. w2 T& A
            }1 h# g/ Q$ I7 _# N& u, U7 s
    . v% {: _7 k1 ^9 n: v/ g7 f
            delete []b1;
    " H+ V2 O- ?( S0 y8 V        delete []b2;

    : f6 s# b: D! q) Q0 D' L: Q4 |
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?: @; k0 c/ }/ b5 Z3 u0 P

    6 @  v9 c0 E: m# q  |% N/ L4 _$ g你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?1 H1 c' l$ i1 y5 ^0 s  x6 ?) O9 I
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:151 [* r  a  ^+ f) C' K! U  q
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?1 \1 _  l  i2 K' |) j0 N5 {1 R

    ( ~) W6 f  P" N* `你第二个试验里面的j在循环里面又重新定义 ...

    4 k# t9 Z' M5 ^; }; B内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL; X5 w" H# V& `

    * k. ~5 ?- M/ m/ E# y9 _5 v& V不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:161 X+ V+ w6 O( W  ^0 n; O& a  ?
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    9 u, M5 v- g4 i4 @+ Q! p; E) P1 `. l7 G+ y+ ?2 V* B
    不和它 ...

    1 \6 a  o6 n. T$ ~+ D/ q4 O
    , N* F' D  F5 G; }8 |不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    2 V1 C! Q' d) e3 z3 }" [2 R* c/ z8 _后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54" C$ I7 ?  H( E
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)+ g. b; P0 u! _9 Z4 {5 t
    {
    3 J  n) k$ k: l( |  Q        comp temp, xtimesy;

    : |9 i+ X: Q+ B/ t6 ^9 ]# M  \这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。# E, T7 Q* b% g2 r  p
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?" y5 d- N% u: k2 ^/ j2 P5 v
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-19 07:54 , Processed in 0.043874 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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