设为首页收藏本站

爱吱声

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

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

[复制链接]
  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?' q& W1 w! N& F* N: z
    3 Y: l  j6 y1 E: j
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    * U5 @' v$ \4 v! y" l( e$ v9 A: V) j3 ^, M3 @1 {/ a* @
    速度优化问题真的很有意思啊。
    1 q$ Q+ J/ |4 `7 K9 J# n" A, @
    ) i/ W* d/ l/ w$ v1 A7 S欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    ) ^" L$ q& l8 K+ R' o4 x把代码贴上来看看?
    , G# V' T) a. R
    ! ~+ ?# |9 n" g- [难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-24 07:04
  • 签到天数: 126 天

    [LV.7]分神

    地板
    发表于 2022-9-24 23:33:02 | 只看该作者
    Maybe Debug mode?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑 * U& r0 s) c4 I2 v0 T
    数值分析 发表于 2022-9-24 23:04
    . b8 V6 P3 G% w. a1 h* T) F拉下来?拉多少?
    + O3 [* m$ k- u5 J6 a7 U把代码贴上来看看?

    7 i* a, c0 `7 l; e) t2 z: I
    5 }  ?! j4 \3 a: Wvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ) M+ O) y- `- J" @9 f- _( b{
    . c2 \9 ]8 O1 m3 H7 y3 U/ D        comp temp, xtimesy;
    & X6 N* U; J, ]; \5 N0 t& K        xtimesy.re = 0;1 c0 ?. X2 ?# N/ I
            xtimesy.im = 0;
    " [0 P" l# U# u% Y5 U( @! q        int j0 = lenB - 1;2 f2 \$ J% C3 d, t. y1 l% x
            int    i, j, i1, reali;
    9 G( L0 z. ]) j8 |' }' {        if (lenA % 2 == 1)
      t5 G. f" E- s' `: k6 C& I. t                reali = lenA + 1;
    6 Z; Q$ H# k9 ~7 L# E        else% v" p: l7 ?7 m5 z, W* l* y
                    reali = lenA;& T6 f+ l6 Z2 v% s
            reali /= 2;* @$ d8 `0 h% T3 V7 G- e. Y$ d8 w. {2 e' O. s
    0 F2 E9 j7 a1 J" h( H' Q2 I
            int nconv = reali + lenB;
    6 v( M1 [2 M# [        //#pragma omp parallel for1 S! q3 P2 S* b# D4 s+ J
            for (i = reali; i < nconv; i++)
    - w+ z) E( R& M: H8 F0 X        {
    4 s9 N! o- B/ A( D                temp.re = 0;
    : {) X' }! @6 l4 F! t8 C) R4 f                temp.im = 0;% C( _$ X2 B' u( B; i
                    i1 = i;
    ) c2 U- c' Q- x; D, e- n                for (j = j0; j >= 0; j--)3 B$ {8 L  p1 T5 I5 y) n
                    {/ U0 L" K4 Y/ w. V
                            /* floating date operation */
      K8 @1 i+ F% W4 [8 ?                }
    # l$ {. [: g, |2 ], V% F- z. D4 B$ Q
            }/ w4 @" g1 x4 f, b/ E0 _
    }
    % A! T- R) ]+ Q4 J/ X  r6 s9 v' z4 p$ R$ x
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    * W9 W) E( \% `* h/ W* n7 D4 \) g- J! @' l5 ^) W, [
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    + o  P- N. C4 R) ^' i% V现在call xcorr 100次,耗时78s.; f# X$ p$ e$ l3 C
    2 [7 n" a7 `1 D, v* Q: X1 d! m) k
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    2 o2 |1 A$ l4 [8 ]9 ?# T% H9 ^  Q, o. h) y& l5 F; m
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    + }* ]* P( L- B  TMaybe Debug mode?
    ( \' r% I' I, R/ ?9 _) L/ f
    9 V7 M2 ~" p2 |9 ?; E9 h$ P+ O; }" q
    不应该,看我上面的回复。
    . w, Q) u3 R( [- x$ {
    7 s3 v2 d5 F  M) N, |我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    1 T# a5 F0 M' h5 H
    雷达 发表于 2022-9-24 23:54
    $ e( {  V% q$ h* F' wvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    , g9 G: J: t: S1 V: F7 Y, O$ d. e{
    & A6 H% l/ W) c# J$ |$ m        comp temp, xtimesy;
    : |8 Q9 K/ r6 U
    " B2 @1 \2 l. w4 S4 ^0 Q; U
    这个不是这么比的吧。。。
    ( M2 q  H2 ]: ?$ m3 X3 c9 ^
    9 H6 I" v0 o8 ~8 f' \1 g" ^4 N) Z您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。0 O) n* j( ]& q: a3 F8 N
    " Q0 h: k# m9 `+ F
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    , d; D5 m2 F: S# h7 y7 c2 A
    数值分析 发表于 2022-9-25 00:20& L- K, x) g0 n" w0 o8 r
    这个不是这么比的吧。。。( |9 p9 h& l+ g7 i$ V$ o7 ?

    $ V# r, q4 K  f, T* M您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    " n0 @" {* N4 F

    : I- T6 W/ U& l+ u有道理。; Y6 c/ T2 X* F; u% ]* K
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
      J+ f1 W, Y, [; n5 ]) M8 |5 b1 v: s' b$ _  Q2 e
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    7 f# f, d5 i" l9 q% Y$ q- l) R有道理。: a3 c* K2 [) H
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    4 o) G+ I3 v9 y& @+ S1 G
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    0 N8 N8 h6 K+ j) MWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    1 K& i" I* e' A5 o: S  u这个不是这么比的吧。。。
    2 M, ]: W; r& t$ x
    ( x2 P4 i- C2 a% F' P6 P9 C  |您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    6 w" q- Z4 a( q5 d* v. v
    ! d% r' u  u  k现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 4 Y# s: d0 u/ Z* V" s* L5 L& p
    沉宝 发表于 2022-9-25 01:48
    ; S+ q( H8 c( K, }/ Z现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    5 K$ y* z0 M$ H# \' T; v
    . H3 H# o. k9 ?5 c. n
    是的,兄台说的对。
    % I' U! U0 |: y# d9 u$ q7 i4 u9 F( j* K/ M; I+ q3 a
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
      o! D5 d" P$ j& Z% b5 V8 K& j7 j" l" b' _/ O9 C
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。  X5 R3 c& Z- m
    - ^+ v3 B  j0 k% {4 @' e
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    + u2 m3 y) \% R. ~6 s/ D
    4 U$ {' i7 L" o当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    ! R) F- m4 D) |/ o/ ^  I* W
    沉宝 发表于 2022-9-25 01:27* O6 |+ W2 t% D. g
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    - `5 p* X: w7 F
    7 m5 [3 G4 N2 B& R$ }) _' {又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    , G7 t& m$ E  w+ `% t+ T/ p  [" ?3 N
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:478 b/ B! U9 |  p% N
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ) k0 A0 T. C6 Y9 `- i+ v
    时间差一倍的结果可以接受。. K2 @/ k+ V" i9 F) ^, k7 _
    ) T' r, k* [) a0 {
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 ! g7 l  t- b; Y7 G0 z
    雷达 发表于 2022-9-25 04:475 |$ u: t- G0 q0 G4 f
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ) f! G  F6 @) G! D) m
    4 T5 [/ {6 S; x( p5 E

    ; I& K# U7 k3 |# r5 f
    / A* m, R; z+ v  V能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 6 K$ F+ J/ Q; W
    数值分析 发表于 2022-9-25 14:585 u+ I  c* h. i
    能不能把这个也贴上来,看看和上一个有什么不同?

    : t, t+ P. S: B理了理思路,重新做了一个测试。
    6 x- q$ B2 o  r+ Y做了两个 vector 和 两个 float *, 都长 100000
    & J5 \) v; h' o( M) g! p2 E外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    , K) V/ s' h3 q
    $ e$ T* @0 H$ o  ~0 R内循环试了4种方法,9 M# E+ e& f" f& L" |$ P
    1. 直接调用 vector inner_product 247s
    . C0 `4 [1 L$ m1 J: H9 ?2. vector 循环点乘累加 237s% m' g: S0 Z% d9 b
    3. float * 循环点乘累加 204s- @2 ?- O) X5 J0 @% ~  c
    4. 空循环 100000 次 202s  e; B7 A  [) G

    * [% N  z: K6 ]3 e不做内循环 200s2 {3 Q6 l; K! P

    3 U" M4 {) J& o1 D; A/ t5 A你昨天说的对,内循环本身占比是很小的,大头在其他处理。0 k' y. }7 c( j, I7 M3 h7 K4 k) M
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    # x$ o" L& b. |) w! A0 W: K
    " ~2 S2 P6 j; v至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)0 K; h5 U( Z5 F. s6 P1 e2 L

    " w* _" c! V4 S) b(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    9 m( n) u' Z4 g/ W/ [  A
    + z! x% e/ @3 j' ]) H# s3 ~
            std::vector < float > vec1(N);
    ' u% V: P& H3 f6 `+ s1 x: P        std::vector < float > vec2(N);. R0 K: j' U2 ]' n0 \: T) F
            float* b1 = new float[N];
    ' \9 N, r, l& k( z, N        float* b2 = new float[N];8 ^% C$ l) a: {( f% Z+ u" d

    3 E- I8 J% q. o+ S4 c$ |6 D8 r        for (int j = 0; j < 6000; j++)! W6 J( l4 f: K6 D" d
            {& O) L+ d: L* G# w
                    std::generate(vec1.begin(), vec1.end(), []() {
    # m6 d3 w+ I8 j                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    - T4 |/ @/ i- |$ W+ i/ ]( f/ v! l3 y* A                        });
    4 u/ g$ ?1 v, d/ z3 v4 E
    % E% u- K% Y$ m1 A" x" l4 F                std::generate(vec2.begin(), vec2.end(), []() {/ {- I0 U/ q8 X- u( ^: f) d8 f
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    ; j5 \% p# Y- L2 r' e: h                        });2 @' I/ W$ a; Z/ w4 @

    5 T! ?( |) p! l9 Z  J2 i                for (size_t jj = 0; jj < vec1.size(); jj++)
    2 h+ N, R4 s% `& G8 u                {5 Y9 Q  ~: [6 Z
                            b1[jj] = vec1[jj];4 U8 M- u' v. V8 |
                    }) Z5 ^' k% v& E+ l2 r
    7 R8 H0 _; D" S: r5 H2 g  U4 H
                    for (size_t jj = 0; jj < vec2.size(); jj++)3 ]7 l: \# v3 y; T3 Y
                    {
    ( ]/ J6 j+ |+ Y# W3 l- M                        b2[jj] = vec2[jj];
    9 K3 Q! h" F) y) a                }  Q2 a& j' z+ B

    - S2 j% |1 w) H  o0 h                //Method - 1  N=100000 247s  7 B1 l6 Z8 |: J+ n) O, d! c
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);& J& }* P0 C( A% {2 O3 c
                                    
    ) c: s8 v) z; I                //Method - 2  N=100000  237s
    8 v, S8 ~; c* X# Y1 i5 \                /*
    * }$ `0 {4 A' l7 N% u                for (int jj = 0; jj < N ; jj++)0 X( w( }$ Z, N8 I$ D- T4 u) S! W
                    {
    3 y+ D: ^3 A- I) ~7 a, T2 R                        fresult += vec1[jj] * vec2[jj];
    # v: Z2 k& ^" `                }
    ( t6 B) L  e6 @: ^" i+ c                */. |0 a. O+ ^7 j7 Q* o5 i
                                    6 l6 X# \4 [0 w$ U* F$ N
                    //Method - 3  N=100000 204s
    ( b; H% p& k: N% t- x& C                /*
    3 i+ a6 b0 N( ?* z2 o8 i+ o9 V7 w                for (int jj = 0; jj < N; jj++)3 i5 r  A$ p4 z$ t. ^% |
                    {
    8 n/ d% F& c, [7 M, I                        fresult += b1[jj] * b2[jj];
    : [6 Z4 l6 i8 e2 r# W                }+ G5 Q8 G/ ?1 q  b6 E" ?7 {
                    */
    $ T, N0 p: s! R  D4 ^3 c
    + T: N' q9 f# ]9 r! b                //Method - 4   202s* _9 |+ C& l4 H( h. Z  y
                    /*( l: q# V8 |8 T  C* o) E+ ]
                    for (int jj = 0; jj < N; jj++)
    / ]; q& v2 v* C9 X( n; ]                {
    * d) H8 b, M/ P4 b( M: A& X                        + h4 o3 s" n8 U; ~4 @
                    }& P. Z& g' r4 B; u" E
                    */
    : l! E) x. k7 [1 j3 P                //comment out all methods, N=100000  202s               
    " k0 A2 c; `. w        }% T! f- j, M+ R  o+ D7 y! d- e5 i0 U9 o

    5 g! [7 f/ f1 P2 G1 I3 l/ ~        delete []b1;! V5 R5 W' e7 o$ M% d
            delete []b2;

    9 C( Y( Q9 i8 W" j" P: ^/ L8 k, c  }+ n
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?8 E( q) u. A5 S1 K0 \

    ( L/ ]8 W6 d; H你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?, w/ M0 i; G6 b( Z. W
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15! r; B" w) a$ G
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    $ [% h1 ~# N% s! I% m9 H# |( z1 v' ]7 O' F: U7 I. E, X0 ~
    你第二个试验里面的j在循环里面又重新定义 ...

    # Y- o. k$ d" k+ l, G内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    6 u2 p  k0 j9 ^" O. I; p8 [* I# _, C+ o  f3 {
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    1 I4 e& T3 A) g, G4 d( a内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    % b7 `5 F( n4 Q& Q
    3 i) K8 A) E2 |4 [1 F5 O不和它 ...

    # d8 A3 s2 e2 c1 K: h; T8 L  u, X1 G9 `8 z% Y$ f8 }1 W
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    2 [5 |9 |3 k9 d/ ], x) t- Q  C后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    ; T4 @! N5 N' v0 Nvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)  J; W" ~4 {. u) |- s) s
    {
    7 ?; Z: @- b; t3 A2 j        comp temp, xtimesy;

    ; W. Z" I, _; a  ]& ~; r这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。5 a  G/ V1 u- s: @2 ^
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    # J  x8 f1 T: L$ g# ]* Q: ~VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-3-19 09:22 , Processed in 0.064428 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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