设为首页收藏本站

爱吱声

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

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?# Q5 o5 |; }3 K7 g, A, S4 J) P  A7 k% r
    - ~! i9 r6 [+ V/ t, d8 K4 @8 Z
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。; u" C8 [! E5 ~" J5 O* Z

    ) y5 P" U: I' u: j2 b1 [7 Q3 s速度优化问题真的很有意思啊。
    ! D8 R; M" E6 q* y0 |
    + r  K0 y1 H' L4 K! q欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    ! t0 H. h4 V! k" A  j; p把代码贴上来看看?* r' b9 R0 {4 T" g

    & L5 E( [" z( U" }+ N+ l! z难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    - `; H0 |, h8 u# G! V; P5 d
    数值分析 发表于 2022-9-24 23:049 N5 o, K2 M0 ~# @: R% E, D- B
    拉下来?拉多少?
    + W3 X! h9 E# O$ r: d) ?  ^! q把代码贴上来看看?

    8 X/ I& g& z. E
    ( L4 `9 H/ X7 D1 evoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    / O. c, J4 _. x& H  B{, ~# i" [. k( ^
            comp temp, xtimesy;$ e+ l9 Z9 A1 b: X. C' J0 o( l0 J
            xtimesy.re = 0;
    7 _  E) Q* N3 F8 p        xtimesy.im = 0;
    ( V1 k* ^3 }7 M3 I        int j0 = lenB - 1;
    * p  P3 k6 i/ x2 n        int    i, j, i1, reali;% I% G. S. F- [& Q, _) N% M
            if (lenA % 2 == 1)
    . v3 ~$ Z0 N: v                reali = lenA + 1;$ k& ^5 E- q$ j3 k9 |
            else; H. R) I. H- g/ M
                    reali = lenA;; B2 L1 \( M4 v" t" o
            reali /= 2;# x# y3 N* |9 t0 A

    3 R; s6 V- r8 X& [9 q" @5 r        int nconv = reali + lenB;
    1 [) Z4 H6 m4 Z3 g( ]        //#pragma omp parallel for/ g1 s8 l8 j% Q/ ]/ _
            for (i = reali; i < nconv; i++)
    1 O& C: Y9 _$ Y. b  ^        {
    8 k: D! q3 M% Y1 ~& ?. T+ S! [7 i                temp.re = 0;
    2 g/ x! {, }- M1 z  @0 C$ H3 b                temp.im = 0;7 Z  w) H7 K' ^& X
                    i1 = i;( S! p  p; B# d/ T8 ]( h1 o
                    for (j = j0; j >= 0; j--)
    3 [; l( v; ]- Z  q( F8 @                {, v: Z9 {  A7 ^  h0 A$ s+ \+ W
                            /* floating date operation */
    , F/ [3 s; B, C* J/ Y& p                }

    4 Q, N' U  F% \7 j. h) K4 J        }% j% {, N# i9 j0 C! C! j
    }! \6 Z( `  M8 h5 b
    6 F1 T* D4 K3 n5 D
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样. L7 a/ L! e9 U# E  i

    2 @6 V+ \/ @, ?红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。6 Y/ z& m5 f! o: u) o/ t
    现在call xcorr 100次,耗时78s." ^& k! f$ R' I# S3 b5 Z
    3 r4 \. c% M! e
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    / u% k; [- O8 x  t
    ' I& p6 Y7 N/ u* L2 f4 C
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33$ M! I  z) Q5 c' m( Q6 d
    Maybe Debug mode?

    . c( `' F/ _' x; ^* e) z; H) e; Y. W, J8 b( Q. H
    不应该,看我上面的回复。
    $ V& Z( L( b6 I9 X# o
    ) I. l9 \, S) F. L4 [1 ^4 Q我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 # F, y% e( B% i- X, g
    雷达 发表于 2022-9-24 23:54& q& K! H! r, C
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    & Z+ g) e$ I2 y2 c! B{
    - `1 T6 g! J! q& T1 c& h9 c1 j- s+ p4 M        comp temp, xtimesy;
    , b+ f! \# C9 z, B7 p% p
    * O& N% y+ i3 ?
    这个不是这么比的吧。。。
    . |* f, G8 M8 ?) ~
    8 t# q9 N3 w/ O. u2 Z  g您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    ) E7 d' m: n) _& Q: h! L2 [9 F# G8 t% W$ f. @: G7 m) \+ t
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    ) }" }* ^) Q- j+ J1 Y  E! ?, b% k$ J
    数值分析 发表于 2022-9-25 00:200 b2 Y5 d, H' e5 L
    这个不是这么比的吧。。。" u; M( D3 k! {, D8 R
    7 B6 S% ~' s5 n0 P+ `6 h
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ( }3 k' _8 J% m' a4 B6 y* w
    / n9 J1 k. U. w1 b2 s8 T; O有道理。3 a8 `. ~) w. T. @& s, f1 o
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。$ F& J% A$ h* o0 I, ^

    6 _9 g- {# k) q- L$ J5 P我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    9 w- n* \4 X8 _6 @4 z有道理。
    . B9 @$ y. H3 A. e% q) Q所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    5 v+ e" W! ~+ Q3 Y+ O6 D7 D你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
      L/ {1 ?' {' X" S( c7 y' e: WWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20. e$ c% @* M0 g* H0 _" G& T: K/ J
    这个不是这么比的吧。。。1 f" ~; z5 C+ i7 I/ h
    $ s; _* w- m2 M5 H9 b* _4 S
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    2 b5 {- ^9 N1 V: H: ~) z

    ' L2 R; S# ]7 K7 `, q5 J现在的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 编辑
    ; s& g4 v! g; B
    沉宝 发表于 2022-9-25 01:48, |% b, i6 G1 T6 F; H3 q- r
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    " c6 k5 n. c: {: A( f  ~0 D3 [
    ) o& s: B) a% U" B4 E8 i
    是的,兄台说的对。
    * K* U1 G+ L' i4 z
    ) F2 d- X# n% a& |! Q) S4 u3 h其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    # f/ n% \9 k$ f/ N2 p
    - O2 ?4 c: ?- P4 S4 W( B雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    * `  t7 d  C3 e, `6 j
    3 h$ ]$ t7 p9 i; K6 N6 y5 R+ \比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。. c' `4 y0 s& D

    ' @# s1 Q8 E- {$ I6 K: A% }当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 0 m+ V7 @/ i$ X$ \7 N6 n# m, @
    沉宝 发表于 2022-9-25 01:27# c8 {. I& ^" j% y
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    * K8 F) ?' {" E0 r; m
    6 c, t4 b7 w8 S6 T: c* T4 a6 i又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    0 O6 z, @" G7 a- L- s/ i
    / S$ e9 o. \3 w/ M我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47$ R0 f: A! @- z
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    $ @* ]5 D; o  {时间差一倍的结果可以接受。
    : D% Q& ]% o$ n* _. r8 s. F8 R. J* h  E) J& G' N. `
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    4 l% D- s5 Z+ V
    雷达 发表于 2022-9-25 04:47
    ' `( Y/ Y- G2 D又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    9 f# P# U( ?7 g
    * M8 w- r7 n9 m5 h; \7 e  F9 r  c
    % y/ u3 b  O% z- m
    * K& T- {0 H' T+ Z% e; ~; z能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    ) S: Y" |. \1 [
    数值分析 发表于 2022-9-25 14:58
    9 Y# n, W" R) Q: W" v: s: k6 T  L5 M能不能把这个也贴上来,看看和上一个有什么不同?
    # p! l2 l" h8 J9 s& o& i1 D
    理了理思路,重新做了一个测试。
    4 L" g8 \' c4 z) \1 N做了两个 vector 和 两个 float *, 都长 1000006 m! A2 o+ Q1 J. f2 S: \* ~: }
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    ) @5 z0 l* H% q: D
    . T" w1 H9 d  _0 L  Y内循环试了4种方法,
    , q( Y' M# z  K6 K: w8 S$ P1. 直接调用 vector inner_product 247s
    * M4 q+ a6 y" m( Y# O2. vector 循环点乘累加 237s
    3 u! w) `! p  p% c3. float * 循环点乘累加 204s% v, p. C7 W& [; Z. \/ g* t1 Y
    4. 空循环 100000 次 202s
    # F& e* w; N, b3 J& h/ M6 y0 H3 X/ E3 Q
    不做内循环 200s1 N1 [; q' e1 c- y1 W

    ; a0 m* |' f! U: S" E7 o你昨天说的对,内循环本身占比是很小的,大头在其他处理。0 a( p% ?: F3 x* G8 V2 R
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    , S3 {' K( t* @0 q1 w% B
    5 s7 H- K: S* P! G* P# h9 i至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)9 o9 a, q0 t2 F6 C2 M

    : x( L+ J8 p& I/ ^/ c+ ~# d(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    , D1 m! x* n, [
    ; F5 _0 A. x0 R( _. L6 [% x
            std::vector < float > vec1(N);. g9 D. E) V2 r. ]6 N7 d
            std::vector < float > vec2(N);
    - s3 ^0 m: e9 d2 l        float* b1 = new float[N];
    3 K8 E) I% t3 Q7 u        float* b2 = new float[N];" J( j7 z) N) i) O

    8 a# M4 ~& r/ C7 ^0 f! m: J$ s. A$ A2 G        for (int j = 0; j < 6000; j++)
    4 G2 Y7 b; |4 z- u- B        {
    ; i6 R& w8 t* {( I/ k: N                std::generate(vec1.begin(), vec1.end(), []() {8 n2 O1 B4 y6 V- {; D7 J$ ]/ y
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;% \: x9 Q, A6 W1 S; i. p# ]
                            });
    5 [$ V) c. \% s
    / [  m" @' k8 r. \                std::generate(vec2.begin(), vec2.end(), []() {1 e& ~% V, I% S- h, t3 O5 o2 [7 p
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
      Q+ c6 ]+ o/ Z. `: e                        });# [' w% _0 Y/ p2 [* r9 n
    ; H" g3 A  B- j0 t/ D
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    , P6 w# A. ^7 E. L0 [7 C* H3 D                {% A8 z7 O8 v5 d% Y
                            b1[jj] = vec1[jj];( h4 a. d$ A) j, I' q$ p( g" f
                    }
    ) n2 a& h% a( N: Z4 B: T; K8 U2 |/ \, e% Z; m- k1 R
                    for (size_t jj = 0; jj < vec2.size(); jj++)" F$ ^; X; {3 n/ E" ?
                    {" A: A1 j2 i# e, W0 h
                            b2[jj] = vec2[jj];6 h9 N- i: r7 `% @
                    }
    . \1 G* o) Z$ L+ W4 q7 }$ L% t& c' o! K! b! W& }& m" D
                    //Method - 1  N=100000 247s  ) h- S+ C2 W- U, G4 ~0 i" A1 z6 L
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);- C9 h# `0 T2 {- Y5 |7 k
                                    
    9 ?7 S* a. p% G+ k7 X                //Method - 2  N=100000  237s
    4 Y# z6 I$ C1 r7 C/ k                /*
    7 ]4 w2 E1 X% f, t- w                for (int jj = 0; jj < N ; jj++)3 w8 j2 b" h; S7 P
                    {: r& x1 w- s+ F& U: l
                            fresult += vec1[jj] * vec2[jj];+ \6 e3 Z. X' u- [1 p
                    }
    . \0 U2 O: M+ w, r/ e; S2 J+ V                */5 s3 N% z/ g4 v* p% m
                                    1 \7 ]; l% d  b. ]# d
                    //Method - 3  N=100000 204s
    4 L0 `+ ]5 p7 C                /*
    & ~/ ^3 {5 Q+ ~" p7 T6 V( q                for (int jj = 0; jj < N; jj++)2 m+ F  H& X7 b8 z! ^. z# p
                    {7 G+ X/ U* w5 M  P% |
                            fresult += b1[jj] * b2[jj];4 d9 o2 x& G7 p# ~) X( B
                    }* C& `# ^/ |* k( \
                    */3 B$ z* [6 y4 D3 X" `: j
    2 c, e, |6 _* d( W
                    //Method - 4   202s
    ) n' \2 E/ G1 q                /*
    0 o! D; Z) h9 u. X; d7 D                for (int jj = 0; jj < N; jj++)0 ^! o0 h" A# U) z  `# U
                    {
    ! C- q" @* Q3 V! z+ l; J% {                        
    8 c; X+ C: x( Q* V* s: @; H$ G                }1 i3 m% R5 X7 c% W, @- R; f. }; x
                    */
    ' z" q4 t% b# f: V; n) o) \                //comment out all methods, N=100000  202s                6 L! e/ y; \) c7 t9 p
            }
    ! {; h, n. p1 J/ y  I% k! ~+ `: B( N7 i+ a4 n2 d/ c
            delete []b1;  ]# D) g2 _; R. n
            delete []b2;

    ! A% C5 K9 [; z& \
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    4 ~! }: h4 n& G! r; B& z2 @' {3 q7 k0 _  p2 f: ?$ P0 p
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    + F9 D+ p# l: z1 w
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:155 L8 x# e) |% V& @* a& ?, L/ y- y
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    / K# H. J/ D) _4 d1 ]0 _
    ' w5 b9 W/ W& y5 }) }9 n' X你第二个试验里面的j在循环里面又重新定义 ...
    0 l/ S! K; i) f5 j
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL3 ]6 {& I8 x8 M8 P/ a+ D5 {/ H& \
    ( }3 g/ p( U9 l. X7 }; V
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    7 }, W; c; T5 o" H内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    % I# v5 `. V" S2 R% K/ B  Y
    & w; S- n) R4 g- }5 V3 J不和它 ...
    6 @, {! V& L8 Z
    ! v! s# D* @+ h( `4 e+ F8 U
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    ( f/ A6 R4 _0 ^5 H后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    ( N: W( z; P) Q* x" ~- qvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    * B! u) F6 Q% v. b3 U{
    9 a7 H$ ]5 E" H  j        comp temp, xtimesy;
    9 E7 v# X* X7 D8 k
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    * d/ |& G+ L+ w8 o. g内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    6 @7 `7 c9 j1 I( f" o. ~VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-7-22 12:38 , Processed in 0.080768 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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