设为首页收藏本站

爱吱声

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

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?& @" p% b: _) O' p
    , G) I* v9 t/ C$ H  B: L/ j
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。4 m) [, r% D- Y& m) ^9 e

    * ~  Z" q/ W1 ]速度优化问题真的很有意思啊。6 q# e2 O% y% G' ^: h+ W8 L3 A
    / f: }' \8 e, l# g
    欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    5 m! D7 o$ g. F& n把代码贴上来看看?
    4 j+ A# o0 B) s& O; k& d  W- v. Y. ^: ^
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 - }% ]* W% J5 C$ p! i
    数值分析 发表于 2022-9-24 23:04# x# h8 Y# f: g  ?! V. k
    拉下来?拉多少?
    5 H: R6 L3 E9 q7 b3 {) x把代码贴上来看看?

    3 ~' K9 b, @% r$ I  |/ P5 c( W# X! G0 \) L) ?
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)+ v/ D# K* e& ^7 @( P- Q3 W' B
    {+ l& O$ U+ N  H- D9 p3 d
            comp temp, xtimesy;
    9 `/ r8 D9 J9 Y: m7 x! n, a        xtimesy.re = 0;& L% M; L) g& L( F% [
            xtimesy.im = 0;3 g4 ^+ i; H; p* J. p; l& {: z9 H3 V
            int j0 = lenB - 1;
    * P, p7 `1 E3 F& C        int    i, j, i1, reali;
    " s. ]6 w; A& K$ r- a, [- c& }        if (lenA % 2 == 1): L, m9 u5 Q$ p3 _
                    reali = lenA + 1;
    : x- E, f) L8 ?4 T0 w# U        else5 N/ D1 d% Q2 f% E7 \8 {+ f
                    reali = lenA;
    - z: T% T' w" g        reali /= 2;4 c! V$ d- v) s6 d. c8 b5 U
    . P% E6 J, g9 H5 p( J
            int nconv = reali + lenB;
    6 v3 ^. v4 `4 n' T* J! h% W        //#pragma omp parallel for
    6 ?. r; g* b( x) G# K7 N* v1 Q        for (i = reali; i < nconv; i++)$ K# F+ q! P/ U3 P
            {( w7 ^0 E; k) @& _9 U1 r' ]0 S
                    temp.re = 0;3 w0 c  P' d/ D5 A9 ?
                    temp.im = 0;6 r* Z, G" [# |# |+ E: c1 i
                    i1 = i;
    1 y0 W' e; a5 e                for (j = j0; j >= 0; j--)
    + L- W9 y7 S0 t/ G                {* u* q# t) Q6 n) H
                            /* floating date operation */9 f, J* {* a' Q1 U; q7 d$ q
                    }
    , R- P# q3 a" [* t8 `$ I
            }. ~9 y) c/ n: i4 L# a4 Y$ |
    }% q2 P7 P( ?/ P$ L$ G; n
    2 p( ]2 d" z. f1 ]* D
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    $ M& ]( E- w+ h5 S1 ]# x, O! V) @; b2 ^
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    4 U  ?/ `0 H* V7 K2 G& }$ ]- {现在call xcorr 100次,耗时78s.1 G6 J& T% J5 u1 v$ W2 t% N

    6 N. g# W! x; g8 \1 K如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. # Z# I8 I0 U8 E. M5 }

    - [5 h3 m3 l9 W. U
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33* [3 H% G( e: j
    Maybe Debug mode?
    # w2 ?6 [# G7 U$ p& N

    3 Y+ @8 {$ e! s% O7 i不应该,看我上面的回复。8 a/ f0 l% ]" D% D( r( h

    3 o4 B4 e, H5 ^2 c  d我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    ' k0 M* E2 f* }3 o
    雷达 发表于 2022-9-24 23:54
    / n+ O$ Y: j: c, j: yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
      C9 T0 ~# K' `+ P$ {6 M0 R{( F" N  k1 y4 |9 P0 e) ?
            comp temp, xtimesy;
    ! A  B; l; V8 \

    8 U* e- K, J0 p4 s这个不是这么比的吧。。。5 F$ A: G8 n1 N; o3 Q8 C9 {

    6 g& p/ D( A, a$ \8 i" o, j# S您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。% e/ V/ U* H/ U9 J- \* T2 ~
    ) w$ I& t+ _! V* ]# ^! V! e7 W. 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 编辑
    ' z& W) D( P3 L' W* E( I
    数值分析 发表于 2022-9-25 00:20
    4 u0 n2 W% k' G8 }' p+ b  T6 B4 a这个不是这么比的吧。。。
    / m7 _) ?, c7 |3 D7 A0 ]4 q/ \! [3 g& T$ ?" b8 C# W2 G  z: V
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    & I) n1 v: h" ~0 w3 l& a. B& ~
    # Y# @' d' e, F# l& d; B& `
    有道理。
    + c  |  V* X8 Y3 s5 Q; H% `/ m$ l所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。! f' ?* \$ `6 a2 h! m& j9 j0 q
    5 h3 t' g+ O3 S" Y7 S
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46: m, X/ J9 e8 F4 y4 w- R
    有道理。
    . a  N" i) o2 F' }( n; B所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    % B/ w8 Z4 U, x
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    & S( w/ Z! p/ b  Y; tWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:207 [3 m# [% E0 S8 k7 l# }0 _
    这个不是这么比的吧。。。
    # l/ v5 j* u, G: d6 p7 t) ?" P% f  T% t1 @; C9 H
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    ' V6 R, W/ j2 h' j$ |/ _
    8 D: w" ?" ~' b
    现在的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 编辑 ; ~; J4 A5 E1 T( \7 F  K5 b
    沉宝 发表于 2022-9-25 01:48
    6 g! x/ M5 p- w& _2 {! b2 P! o现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    # e4 q& H! E7 r" m$ F3 @& o
    : }8 P- S+ P& u: Q: [! {2 V
    是的,兄台说的对。2 f; t7 C  G" C7 X

    $ ]0 l! u! R) f8 P其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。# o7 e% {; Q; C8 N2 e) n
    : f0 D, X% `, r. j) i3 G3 D
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。6 x: z2 r- m) {5 d

    5 l' C: D" l% Q* k2 V7 K% Y比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。  |% J4 z* N+ z+ c; \) ~
    0 ?- E2 V% W* m$ f* F
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 7 y/ N7 ?* W' Y: H& ^' [
    沉宝 发表于 2022-9-25 01:27
    / n* F2 Q. \+ J* w4 ^5 t你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    7 s2 B7 w; k0 O5 ^# s; Y

    . g; u: O4 {, T: d' W/ ~2 l; b又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。/ K- C5 u9 t6 @

    . H) \6 z4 L! B$ ~我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    2 x% h  x/ x5 E0 v5 h. p1 v, n# x又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    & q) @6 b7 `. [8 U2 ?  d
    时间差一倍的结果可以接受。
    $ w, G9 [! Y. C& A1 ?. G3 B9 ^/ j' t2 ?
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 , [' y6 G; `( s
    雷达 发表于 2022-9-25 04:47
    + M' y- H0 [, E0 m又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    4 _6 H* H  S; [5 g" c

    3 Y2 E& K: [7 R9 S4 Q8 [( d; n
    $ n; P! _/ o# j- X; g5 r, g: H3 K4 z) g% U, K8 }
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 2 H8 h" ~4 h$ q' z( @. S
    数值分析 发表于 2022-9-25 14:58
    * J4 M- h3 j2 Z能不能把这个也贴上来,看看和上一个有什么不同?

    & I. b8 N7 N) v4 E! B# s理了理思路,重新做了一个测试。) W/ T8 P. K& e
    做了两个 vector 和 两个 float *, 都长 100000
    / K7 w( M  ~+ s0 ]% q/ [外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.$ _0 j$ _9 H/ U) _% N9 [# {
    9 V- n, ^: Z$ Y  @7 }, c
    内循环试了4种方法,
    ; u% t# S+ H! n3 o, w; [) e  X1. 直接调用 vector inner_product 247s
    / C8 P0 M6 v! w$ w2. vector 循环点乘累加 237s  |) S$ E2 c- G0 B! T% q0 @
    3. float * 循环点乘累加 204s1 n: \5 G  J+ A% u
    4. 空循环 100000 次 202s/ R* o+ {, L" ?. u$ `7 Q6 S5 c

    8 J$ \9 M/ v" d# u) Z+ V不做内循环 200s
    - ~1 W% g; i9 K; J/ G% d
    4 {3 h8 ]5 b; j6 s( {' Z: }你昨天说的对,内循环本身占比是很小的,大头在其他处理。; [+ {" z" o# n7 z" j9 l1 i
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。6 H/ `0 T4 P7 I) t; X: f. C% _0 X

    # t! d& b& |# ]( W/ A至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)5 [/ [0 n4 d$ e: t) k0 l- S- w

    " F5 u2 A: _. R+ j. M% I' X(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
      Z. J$ ^' b/ V% H: E& ^' H8 j" S9 A# F4 I
            std::vector < float > vec1(N);6 u$ c$ P3 l/ N  H
            std::vector < float > vec2(N);
    4 R( @8 D  z# N4 H' }3 [* W% u        float* b1 = new float[N];& n; {2 Y1 K, A2 C1 {) G
            float* b2 = new float[N];' X! V7 |( n1 a* R& B# O
    - d/ Q# x9 c$ R! @1 |
            for (int j = 0; j < 6000; j++)
    7 y6 D: R% k1 T2 P4 M        {9 e& [: l% _: S& q1 W
                    std::generate(vec1.begin(), vec1.end(), []() {
    5 v4 W( f' g7 I' H* v/ b                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    9 H$ V* T4 s- M                        });1 F+ |5 J1 q+ Q6 ^* q
    8 s  I! W6 `  |
                    std::generate(vec2.begin(), vec2.end(), []() {/ X$ v7 `5 f1 \! q3 A' G5 c
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;: D$ S+ @3 H3 J5 [9 X
                            });
    4 H, r5 ^9 L+ ^5 d1 P1 F$ ]7 }# d0 o3 H# f4 |) r
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    0 k' K) _5 {& P0 ~                {$ K- ~# }! l! Y% |; t2 o
                            b1[jj] = vec1[jj];
    ( U$ r; H$ a& w0 D5 W6 u                }; N5 N1 d7 a7 q3 j% a  F$ a

    6 J, `# f, M+ L) J# {0 |$ L0 J) G" i                for (size_t jj = 0; jj < vec2.size(); jj++)( n! F5 ~( S% ^, r9 u* f
                    {; p- I' @; R1 m# Q6 `/ K2 _
                            b2[jj] = vec2[jj];8 L+ g. B2 n6 l9 p) L. a
                    }, @1 Z+ ~) y  i: P: v# m8 v

    - u7 P1 o" d/ ~2 {" C2 ~                //Method - 1  N=100000 247s  
    4 G# G- j! q& F: \/ `  t* i( ^/ C: U                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);0 {( D; p& z2 i! }
                                    5 C' V; v1 F, _
                    //Method - 2  N=100000  237s
    : E: V* @, \0 }6 c8 B- F! G6 N                /*6 A3 S* g. t7 K, ^, t" l
                    for (int jj = 0; jj < N ; jj++)( y% f% ~  m! y/ W  |0 J  f
                    {
    ; z4 n" C8 {. g' N$ y& ^                        fresult += vec1[jj] * vec2[jj];
    / A9 Q  l( t' d. P8 s                }6 g; z9 ?& Y  o. X% c4 z$ I
                    */
    6 ?6 N. a6 G" s; A! D                                
    ; [, h% H' ^/ |0 }1 l+ `& i4 j                //Method - 3  N=100000 204s- u. Z$ N; b7 z
                    /*1 g! X& G1 }. {8 n4 q
                    for (int jj = 0; jj < N; jj++)
    # R( e3 _+ W$ H                {( |) i  b/ B* I  l3 V$ T" R
                            fresult += b1[jj] * b2[jj];
    ' J! F! T7 Q# D* v8 N2 @7 E                }& B  L& H% |5 b: [. z9 |4 r' S
                    */" t/ ~4 c5 r  `% ]: n1 e
    7 y  a# Q, F; \0 a% p
                    //Method - 4   202s" q$ B$ Z/ g2 b; e- z
                    /*% h" ~/ z9 q1 @  Q; Z2 {
                    for (int jj = 0; jj < N; jj++)1 o( f$ c  ?& I0 c4 a2 J; Q
                    {
    $ `' w' H- v9 r                        
    9 i9 o5 v0 n  z) z                }; O4 Q  F- ^% Y
                    */
    $ K5 j1 }6 p- |. m$ S  E                //comment out all methods, N=100000  202s                5 y8 l+ j. P# D+ z( q
            }4 I( T3 S: I  @* n9 `
    + j- Z6 s5 O+ S5 E
            delete []b1;
      k) E0 \) ?- s. S0 l1 m        delete []b2;
    # ?( o8 I9 Y/ _! a; N& m1 a. n2 b
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?' Q' w0 J' U& F- Y/ S' @
    3 V0 i2 [. w9 c
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?/ P# W2 O* o) F9 A" P* g
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:156 R4 P9 A) @. r# ]
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?9 f9 ?0 u! p$ J- D3 Z0 i

    / ?* n' K9 P/ p" ]你第二个试验里面的j在循环里面又重新定义 ...

    / k9 a9 c- p, s4 g! @0 R内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    3 O0 W  r- i/ G+ L8 O+ \" X" Q: e& g$ {6 d
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ) Y, w/ H$ T6 q) G内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL2 `7 t: P! J/ m6 a" ?; P6 z3 |

    ; N" _2 k$ \; K9 x1 B5 `# c/ |8 g0 \+ B6 x不和它 ...

    , b2 X! T% y% l5 T1 x7 x! R/ W1 b% l6 `$ z! k5 s+ z& Q
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    ( {1 {' f6 a7 k, c后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54/ Z8 G. ?0 [; x( M4 U! G
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)" V$ |/ p0 p6 w% C' H
    {
    , o* x* N" I9 ~6 `0 f        comp temp, xtimesy;
    . c' D7 X* B1 @! a$ I! }
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    9 p* ]/ k2 w+ c% {* w! J' S; V内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?6 Y2 \, l* w% E. F/ I
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-7-1 20:45 , Processed in 0.072740 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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