设为首页收藏本站

爱吱声

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

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    ; h9 E/ G9 J1 N) d5 v$ J$ \' Z8 A2 l4 K( ~  H. G
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。, I1 G0 C( w, {
    * l! a4 V: b0 f9 y
    速度优化问题真的很有意思啊。" ]" U! u9 [) g/ l
    1 b) l, U3 ?- A' l5 v! }5 Y+ h
    欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    4 p1 v+ R, y+ W1 E0 Q5 I. R$ _把代码贴上来看看?
    / a# C5 B$ d% ?
    & B1 `1 g  [* e# W% s难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 2 Z2 C9 l3 r4 t- m3 J
    数值分析 发表于 2022-9-24 23:045 C3 z8 |3 f- ^) r" F* _8 @& X) l; q
    拉下来?拉多少?
    - [) R5 ^- |# \9 `- R, V把代码贴上来看看?
    1 V( N0 X: a3 o  g; Z

    6 r; j1 z. C1 ]void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ! P; D4 Z5 T2 a) o, ~( {{" M& @1 A8 v* ?7 d
            comp temp, xtimesy;4 W! L1 v3 S# a2 p" }8 b3 ~
            xtimesy.re = 0;7 j7 m9 y7 C1 n1 q+ k
            xtimesy.im = 0;
    % j) j& v2 L- H  \9 z8 ~* F        int j0 = lenB - 1;2 R2 V' k, C. x8 p( A: _0 M
            int    i, j, i1, reali;
    ) o7 g/ n( e0 \6 f( `        if (lenA % 2 == 1)
    4 p  U: I9 W6 P# U& d                reali = lenA + 1;
    0 J+ P  o4 Y, D  X        else
    8 }1 I; E+ N3 u) o                reali = lenA;+ K" A8 q; x" e) E1 o5 |8 D
            reali /= 2;
    , j6 M6 |# x; B0 P9 f, v& h8 N0 ]9 ~- m' O6 `- g; B
            int nconv = reali + lenB;
    - J% R7 J4 a1 q2 I0 c; m        //#pragma omp parallel for
    8 i* S8 q# R* B0 f4 \( H! K        for (i = reali; i < nconv; i++)
    - k* b% p* U3 x        {7 |1 O$ [# o9 w$ Y
                    temp.re = 0;$ Y% d6 S, s8 s8 U, `$ R. N8 v
                    temp.im = 0;2 ]* n& J2 v  R' L9 Z
                    i1 = i;- N0 P2 g  ~# f* G) |# b! ]
                    for (j = j0; j >= 0; j--)
    * v3 h  p0 D" L' h                {3 }9 Z6 Y! ]/ x/ @: [; b
                            /* floating date operation */3 f  k9 z9 t( `, b
                    }
    9 S$ [8 x$ G/ a6 k+ D6 A
            }5 |1 {- @7 }2 T
    }+ Z% D! D& r7 _6 E2 C6 D. @+ C
    $ t( a' ]3 T) H
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    3 {! K+ b) w: @( Z; s+ I8 N2 k+ j. G5 K. T/ F- [
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。3 D  B8 G) \) D
    现在call xcorr 100次,耗时78s.3 \5 f( Q) f6 U2 ?  I) M$ P

    * ]$ G9 F. {3 C& D) d如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    : a" Q# y, C$ s5 L+ [7 j# i# j0 p, o4 R: t
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    * g7 }  c4 [6 X* S& X8 L8 F9 JMaybe Debug mode?
    & D) G9 X7 f, s7 e$ O) v" C
    1 ^) [: T6 ?+ _/ Q) m; t
    不应该,看我上面的回复。
    : m" f7 o1 ?5 D) g# s; A$ D2 M8 w
    3 o; R" I3 N& Q: j) h2 W# }* m: S0 w我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑   H; }" f0 V+ M" ~% E
    雷达 发表于 2022-9-24 23:54  N$ A% Y/ D1 @/ N& q
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ) {/ W1 ~7 V1 o( A  F2 C- W: }{; }6 X/ M. {; e5 a- S
            comp temp, xtimesy;
    1 z+ r! k+ C4 d; ?7 e: I, ]

    0 V* l( G3 P# j% }/ _: ]这个不是这么比的吧。。。
    1 S$ m# R+ [2 D
    ' E. ]6 z! o. q, Y您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    1 S) B- Z6 J2 @7 N* H
    2 U! J, `7 U, i2 s$ k( n而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    # Y* U4 J) Q' x' T
    数值分析 发表于 2022-9-25 00:20
      {6 w; i) `, Z2 L1 W2 O/ B这个不是这么比的吧。。。0 Y* g( G6 u( T& n' w2 o

    ( h8 p1 _- T3 s3 v0 e, _& \/ I您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    4 L/ a5 z( R& R, e% i1 U5 Q7 P: I! P! U
    有道理。: x, C) |: {0 h& g! i4 U
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    & ~% q+ m, B& X9 g8 w: H2 N' x% v% w% W9 ]$ v
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46- ]- }5 j; X# _. e9 r- [9 b
    有道理。2 F$ G9 Q1 r7 v: u
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    1 K- @4 F% S; w) x% M你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
      W( }, R% T9 d7 d9 P. f; D* W$ ]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
    ' e" K. J; b  Z这个不是这么比的吧。。。# f! {4 |, x& @  k! W
    7 {1 f% F8 s! |4 Y3 G
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    & v. p8 _. g7 V! J5 J, P
    7 {1 f: ]: b0 s6 _: {2 l6 S现在的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 编辑 0 X4 ^) U0 J3 e% R
    沉宝 发表于 2022-9-25 01:48* s" b0 [/ P: t& B- W8 i' |
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    : e) J, ]5 I( O
    * k0 n8 c' o6 J& z" T
    是的,兄台说的对。$ Y# @. W* W6 W8 {7 Q. P$ U

    " w1 J  h6 n* K  r; R! ^# G其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    ) p. n$ X) U, z$ _, C3 R" C) h# Q4 t" D3 ]; z+ u
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。6 i+ e. @! y6 u" v

    1 v5 C9 o2 O. ~/ d# I/ M& K. Y比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    , F. y. f3 z) a) V' o  O. b2 a0 A' F" e" \- O
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 : n) ?8 D; H- G$ c8 Q
    沉宝 发表于 2022-9-25 01:27
    7 G. F) O# j: L3 J: {' N你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    / Q( A! v9 L9 w2 r( E6 C
    : [9 Q  S7 g2 O9 a2 w' M. }
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    ( b/ h# d8 q/ u
    ( E8 h7 ]  ?& C% }* ?5 o% O, ^4 [我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:478 f+ c7 _0 c+ d% L
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    - N% }. u8 b3 \时间差一倍的结果可以接受。
    5 J. K& `  Y8 q$ m; b) ?
    ' e! @6 o: h$ V& O2 Y9 l/ a你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 6 |8 {& q4 W# u) s6 h4 e
    雷达 发表于 2022-9-25 04:47
    - ~! K" \+ Q8 z) c, n" |6 M又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    5 I6 `& r" G) ~+ }# m
    % s$ @- w% U: X* D  v$ t
    4 A) U( z1 ?0 K1 X4 {
    3 w- n: T; M9 u5 n  u2 x' R
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 # i9 A* {" a/ G2 N# k* b; b
    数值分析 发表于 2022-9-25 14:587 I' Y9 Q8 p" }% l
    能不能把这个也贴上来,看看和上一个有什么不同?
    8 ]1 l; P  f( u3 p3 E
    理了理思路,重新做了一个测试。- g4 ^# P( G2 z: z8 S" }) T
    做了两个 vector 和 两个 float *, 都长 1000002 u% w; ^0 y/ R& ^. `/ E
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    ) [* ]3 N- Q2 O- ^7 G& ?9 e0 d' A$ `$ l0 u8 K/ |" l9 i# Z2 T# T
    内循环试了4种方法,
    0 ^. W, Y" t& m* _% q1. 直接调用 vector inner_product 247s
    , {9 I, O0 h4 p& i  D# R& ]  e2. vector 循环点乘累加 237s
    + r1 o: m2 g, U  S% Y* y3. float * 循环点乘累加 204s
    0 D' ]$ A& P6 Z' A  _/ i& I4. 空循环 100000 次 202s
    * K# i( C+ d8 ?4 K' f8 h
    , U4 o5 }" z6 {$ y0 F/ y  d不做内循环 200s
    ' Y. v1 N: K) `" x- l' X* Q( `: C8 u# B" o
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。0 l7 B3 e- W; S/ t. `! Y
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。/ e' b" v" V+ Q0 P& Q

    3 M, B: i; F  @至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    8 x2 J0 f& Y) \  x9 `
    ) G1 M5 N+ ?; y5 V  }$ y8 I; R" U7 P(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    , C; l0 u! k* P- @& ~
    4 d8 y( s5 y1 a% X
            std::vector < float > vec1(N);$ G+ B4 H! W$ z; G7 L
            std::vector < float > vec2(N);
    * K0 ?. R$ b) q& `' _& H$ P        float* b1 = new float[N];' G# U" Y4 ~$ d3 j4 T6 r+ L
            float* b2 = new float[N];  D& {/ C3 X7 n2 _& l) c; m" s- _

    # M' e& R$ f. e4 @        for (int j = 0; j < 6000; j++)
    6 r% R+ r! a  E- n        {
    ' [! a4 G) C4 F, S) u2 Y                std::generate(vec1.begin(), vec1.end(), []() {
    + _" P: E: G$ J5 I7 j& Q6 B& J- A0 v                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    5 a/ {( D% w! D4 p" L( ~' w  y                        });
    " U1 ]; k# u7 y) T5 X$ C5 p; r# W! [7 N8 {4 ?
                    std::generate(vec2.begin(), vec2.end(), []() {
    ! Y0 T3 D* H" \2 ^                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    + \) t2 |6 u. ~; b/ q0 Z' W                        });/ K, E& Y0 \+ |% I' n

    . x/ t( V% d+ w4 j9 |+ ^; W                for (size_t jj = 0; jj < vec1.size(); jj++)( S4 a: s$ z  s. c5 S. o: y
                    {! W5 h; v/ Q1 L8 u$ T* ^
                            b1[jj] = vec1[jj];
    5 `" _8 `" c. v; Y                }
      Q# Y. a# r  L! c8 [, A8 A
    + E5 w% U* w' e2 G- P( Y( U& H                for (size_t jj = 0; jj < vec2.size(); jj++)
    5 l# S% Q1 V5 l# h; q                {1 ?$ i/ C2 B: R- w  k8 b1 p
                            b2[jj] = vec2[jj];
    * X- j: P4 A1 ?                }
    * B; a6 L2 V  \' G" k8 ?
    1 b& Z! a& D+ A                //Method - 1  N=100000 247s  
    , i( b+ o+ A, ~" g5 i- w                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    ! P( M' e6 a5 x' P                                7 s1 V" b( ^+ ]1 Q/ ?9 Q) H
                    //Method - 2  N=100000  237s5 L7 J( Y4 l+ b5 X% ^7 @& w6 a0 ~
                    /*
    ; z* t0 Y1 m% A) n$ ]                for (int jj = 0; jj < N ; jj++)3 B) b9 @! J, o9 Z0 i% N  b
                    {
    8 Q$ |0 n$ O) M0 p# \+ y# v- J0 g                        fresult += vec1[jj] * vec2[jj];
    + R( A: A  I, f- @0 K/ e4 B7 Z" j$ u+ A                }7 N5 d: y8 F7 }1 I/ }$ @
                    */
    6 G1 w$ R  D2 i                                * G( `  j6 D1 V$ Y6 z! _
                    //Method - 3  N=100000 204s8 p2 C6 i' V/ U# {$ E
                    /*
    ! [6 N- X& k. X, G' F# p# ]                for (int jj = 0; jj < N; jj++)
    * _/ y9 R5 G  `2 ]& f/ L5 z                {" R7 l; q1 T: R' f2 C) w9 p" O
                            fresult += b1[jj] * b2[jj];+ T3 ]0 I9 m5 l" Q/ ?4 n- E; \+ N
                    }! Y- y2 R) C3 \2 O1 ?
                    */
    " @) Q# L0 E# a# X  G" [. B, W
                    //Method - 4   202s
    % e: t" @4 S% A/ y6 b                /*
    - b: X- W% k. e% s! i' A2 f$ E                for (int jj = 0; jj < N; jj++)
    1 d/ j  |5 N& ^4 q( B: ^                {3 Q& |5 r, U9 I/ @2 k7 _6 [5 e9 s: U
                            
    5 `3 D0 w. K0 t& e8 }" B                }9 u) e2 F- R* l7 G: ^" B$ s
                    */  @' w! D+ F/ M) A+ @
                    //comment out all methods, N=100000  202s               
    5 a+ k" m  d; F% ]        }
    : ?9 N* Z9 C5 o2 q3 k* g2 W8 G  u3 C9 P( A" q( H- c
            delete []b1;
    7 N( _9 T6 E# M$ c& q$ V& b        delete []b2;

    & w' E# b9 \& d; f
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
      h/ O  _% c+ w( E+ l8 m" G) [1 B) C( n& l
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    $ ~# U7 ]' {7 I
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    6 b3 b- i; Z# h! O; y& M" y瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?, q6 c$ s+ T. t$ n& Q

    ; g3 _2 c- c4 x你第二个试验里面的j在循环里面又重新定义 ...

    % ?3 h+ {! m; |6 B内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL; x4 \. q6 l) ^" V/ b

    . p0 q; c% h( G% ?5 B' P不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16, y) }" \/ g' F2 f3 o, z
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL/ G$ j1 v& e+ }; r% e
    + b# ?: @7 u2 `2 p
    不和它 ...

    $ B# M7 N. c* j+ e) u) d! i0 f
    1 `& O. I& a7 Y2 x2 K不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。& S+ }9 i; L3 ?+ {  V5 F% Q
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54. ^$ P/ Z5 b: k, A3 G
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    : x1 v* N1 V* y" S) a{' H6 l( U" Q, }4 C% A) H6 i
            comp temp, xtimesy;

    ( V1 E4 L3 x5 ?" J' T1 d这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    ' S/ ?# _+ F( t内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    6 g+ t0 x6 a5 J& {VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-7-22 11:31 , Processed in 0.067321 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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