设为首页收藏本站

爱吱声

用户名  找回密码
 注册
帖子
查看: 4909|回复: 25
打印 上一主题 下一主题

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
      G& q' @% N3 w+ F! Q# q! T
    1 K+ F5 ]" S# P- `3 f自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    ! ]8 O: b3 Z5 Z" ^5 ^5 h$ W2 @1 F, C" g
    速度优化问题真的很有意思啊。7 D4 E" o& o5 ]2 s! |  U+ R4 ~
    $ N: U5 c; }! u" j6 }2 {, N
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    昨天 02:31
  • 签到天数: 1855 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    0 v& V7 w) h4 g$ G" V把代码贴上来看看?+ n* i! F7 E- L/ M  k

    8 F( w4 i, Y8 {; q7 W难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2024-4-22 03:36
  • 签到天数: 120 天

    [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 编辑 & w4 y% ^. O6 o3 j6 F5 ]% g# D+ x8 u
    数值分析 发表于 2022-9-24 23:048 d# `8 F" B3 j- e
    拉下来?拉多少?
    " D, s' E' l7 b# M1 A+ U; u把代码贴上来看看?
    0 l( C0 e: T$ y: v( ]
    ) C9 I- G6 R) N
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    * d% n: f4 k! \4 A& @2 n, p: m( i$ }' Z{
    , a( Z0 a6 W! n9 [+ i        comp temp, xtimesy;$ T# r" A2 R+ }$ X
            xtimesy.re = 0;; g7 L$ o+ d1 X4 ~9 e5 g" ^3 L: }
            xtimesy.im = 0;
    ' r" H2 x9 \& F& L6 _  D8 X5 R        int j0 = lenB - 1;
    % C4 {- U8 f2 f2 J  q        int    i, j, i1, reali;8 Y9 K1 a8 v1 E7 c/ M
            if (lenA % 2 == 1)
    4 F$ m& I( |# c4 C3 {7 W                reali = lenA + 1;& y9 y, Z. s" v# b4 {
            else# ?- C) f3 d6 p! Z" Z' k2 M
                    reali = lenA;
    ) C- ~: ], d0 k& u        reali /= 2;
    , u# m7 |" Z$ y. |, A$ T' R) y. d& W" ?* e2 O
            int nconv = reali + lenB;" S2 M& {* p. H! j9 m0 S
            //#pragma omp parallel for3 y& x; t) h# A3 e
            for (i = reali; i < nconv; i++)) W  y. S+ d/ @5 a! F
            {
    , @6 F3 d# p7 p; F                temp.re = 0;0 v2 s5 m1 [% Q0 \& x
                    temp.im = 0;4 [, g0 i3 C! i8 X6 F
                    i1 = i;
    * K/ S- ~5 r6 Z6 K: A                for (j = j0; j >= 0; j--)
    * \) p1 I$ U9 `% o  B% m, y                {0 D! S4 p2 F$ _" T; `" |
                            /* floating date operation */
    # N4 z. D8 q4 `                }
    " v! }& k, T( u1 G9 q
            }- f+ ^( i6 E; P' M; t% [; h( N/ y% [
    }
    " D" X2 h! _/ s! [$ `
      l7 F; I, S0 @0 ixcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样1 d3 u; x2 x+ H3 f5 L
    . a+ a6 r7 ^! Y& G7 k  z  }2 R
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    2 s( i0 p, @6 d% j5 T2 W; q4 J( E" U现在call xcorr 100次,耗时78s.0 g+ M; _# [  X$ j% _4 o$ Z4 D' a

    ' W' K  i# H' j" D, y: E0 l+ n如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. * ?" V6 c% _2 w) t5 U* U
    1 ^, `; d" ]$ |1 G6 v" O# w% {
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    0 N" ?' w/ z4 @8 d: h# ^$ }% XMaybe Debug mode?
      x1 F2 N' z! P) l
    * Y0 z# t6 T! @, T) ^
    不应该,看我上面的回复。+ G5 b1 e* @+ V6 r; q0 o. m' S" h  j

    9 G2 I9 _/ J* \7 v8 Z6 Y我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 02:31
  • 签到天数: 1855 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    1 @0 t3 E1 A7 W# N* |  v0 j
    雷达 发表于 2022-9-24 23:54' {4 {* s+ F/ K
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ( O6 ^8 u& w0 V' r( c{
      R1 s$ b0 ?, S        comp temp, xtimesy;

    0 Y) ~- P5 W' M7 G( h  m4 Z& a/ v) t) F; M
    这个不是这么比的吧。。。
    / V% a5 `* G8 O* i% t  ~
    3 c* N8 T8 t, F3 L. V) o  W您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    " @( h" l8 g7 v
    7 a; X. W1 ]: w2 y# l6 L/ _而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    : J  M8 d# T9 ?+ L- Z  y" O
    数值分析 发表于 2022-9-25 00:20
    1 V: }4 z" u& z" w, f" z- E. Q, f3 H这个不是这么比的吧。。。- y2 [, ~' k* S) ?

    . E8 f7 I5 @/ j9 |3 H2 Z您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    9 c  q6 i* o. |& V: y; Z* ^
    % G% E1 @3 ]" y' o6 |& X; d. L有道理。
    8 I! p7 s0 ]3 Y  ?, x0 ]% r所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。" t7 [& b2 ]2 U! T/ F

    5 a- K+ g2 q6 y: y8 c1 ]4 i我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    8 y! X5 f8 j/ Y& |# O有道理。' v2 I, L; D0 O4 F. \1 u6 |5 t' C6 b
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    & P( |  I' P4 V7 n! \  V9 X! O你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多7 x' n* {+ Q0 u# i1 k
    Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:205 m1 X$ N3 ]& A/ C
    这个不是这么比的吧。。。& n3 s9 ~0 {: A6 W6 e
    : W9 s3 t9 [1 Z, |' W3 s* \; N
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    . C% a3 n4 w( G  a

    % l$ H; o0 o6 S, Z/ A) w* \2 P现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 02:31
  • 签到天数: 1855 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    - p  P2 e* n% M* r) a, M0 T' k3 S
    沉宝 发表于 2022-9-25 01:48
    # j6 U$ K! Q2 ]& M4 U. r, W4 i" l现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    ) g# @1 ~1 E6 e. D7 z3 K- _; x- H9 R- Y8 ~
    是的,兄台说的对。
    ! l( S4 S" @/ p* r& s. p% W8 I1 F1 c) w* n+ k5 u
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    2 d- i" U; T% u) [  r) H* V1 j" U
    ( Y6 R7 {7 w4 M7 I/ S) U雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    " C+ j2 h2 `: n5 f" }& Z+ t$ ~3 l/ ~
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。# J4 T2 O1 Y4 k* R3 u3 e/ ~
      ]  @  u5 E6 }% d
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    * x$ h, t9 P5 ?/ P* x* I
    沉宝 发表于 2022-9-25 01:27
    4 t! U! K4 ~& b2 a! |( y2 N你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    $ T  X5 V* q8 V
    7 ^6 t7 N: x! [$ r
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    6 A7 [8 y' p& z4 {9 M& g, F' d0 L- o' p: \7 G# s: `0 [" t, l# O
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    0 L# b0 b, r0 @# N% o; L6 I又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    . M/ m; w9 c. I0 [! K2 l! g
    时间差一倍的结果可以接受。5 |) L$ _! e% Q$ I3 o
    . E; B2 `" @1 g1 l$ b. ^9 V
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 02:31
  • 签到天数: 1855 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 5 [' i; c( }& `+ e( g7 L
    雷达 发表于 2022-9-25 04:47
    3 Z  _, f2 j) h8 F: h又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    % v% @: g# m3 Z5 K6 k  ^

    7 q& G% h2 k  u7 ^: I
    # r0 W* [( e( [) {  Y* o) u& \5 [+ t5 l6 c& X, P5 F3 |
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑   Z# {  @: F! B
    数值分析 发表于 2022-9-25 14:58* S+ n8 c9 \8 |
    能不能把这个也贴上来,看看和上一个有什么不同?

    - x$ a% v# F8 }& A- f理了理思路,重新做了一个测试。& ^& p( c5 a: Z$ U3 \& Z
    做了两个 vector 和 两个 float *, 都长 1000002 l( x$ o% O& a, ]
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    / _- l) X6 ?, G# }" C) v  F
    3 P" a! P& }9 w. r! k' y( S9 e内循环试了4种方法,/ W% G: ~( k# }" x8 J
    1. 直接调用 vector inner_product 247s + t6 g- I& s; ^1 g2 K* Z
    2. vector 循环点乘累加 237s. Q; {5 H# c" ]' w3 `3 {' ~
    3. float * 循环点乘累加 204s
    ' Z2 J$ j2 B6 z4. 空循环 100000 次 202s
    ! {1 P2 D2 A% G9 e7 ]% Q; V
    - @; k. w, `$ b* N- L7 Z不做内循环 200s+ J- S0 H) J; Q8 v
    0 q! M3 Y( t, `3 R' `; y
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。& T- T9 P1 U5 u2 f
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。7 _2 I9 d1 Y. u- A- c' I! E- X2 Q

    2 k+ ~) J9 b- }: L, C' B7 z至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)) |3 G/ e+ h% @+ @  p9 |
    . x+ v# V4 T6 n0 B! s
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    7 j# U8 N) M2 I! E5 D9 [4 O! V1 Z: [
            std::vector < float > vec1(N);
    4 m6 O, ?* x8 l1 N, U* ?# j% g2 J        std::vector < float > vec2(N);
    ' R! z6 `( X$ z5 x        float* b1 = new float[N];
    5 g" Q3 V' P( t" N        float* b2 = new float[N];* o( \8 ^& G% ~, \" [

    8 |  q# j+ X. @5 e! H" U        for (int j = 0; j < 6000; j++)
    8 U  Z$ d1 G$ x1 x0 O. U        {
    4 o. B) s/ A$ Y                std::generate(vec1.begin(), vec1.end(), []() {3 z8 b1 b5 V+ L' \  u8 a( d- U8 d
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ' ~! p# r  R5 {& L0 e: ]$ Z$ b+ U# {                        });
      W( W0 ]0 h! s0 _6 G7 M8 x" R1 O: x3 d; P" S
                    std::generate(vec2.begin(), vec2.end(), []() {
    8 b# i9 j) D. ?9 q1 v                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;. t/ \+ `1 L+ l3 b
                            });
      ~2 d# a+ z1 o* e1 M" i* W6 T, B) v+ L( r; o" }
                    for (size_t jj = 0; jj < vec1.size(); jj++)/ w" m1 k( C9 R" L. @5 D- i3 @
                    {8 i+ o2 s* k0 H' Z9 X, g' d
                            b1[jj] = vec1[jj];
    6 G/ Y: n7 D0 J6 W5 Z: V1 D+ O                }. q* I0 i8 t, L6 ^$ X( J0 _

    # p9 U4 w* l6 r                for (size_t jj = 0; jj < vec2.size(); jj++)
    ' j) y8 O7 F' G  H7 ?6 F                {
    " h; y: G( v' C' l$ T' b                        b2[jj] = vec2[jj];
    ! @# E$ X$ t+ ^8 {4 p                }; j  p6 A; T4 c* n% ?* u

    / h$ D/ ]1 H. ?7 O                //Method - 1  N=100000 247s  
    ( K) v+ |! @. ~: g                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);7 e: P8 \" Q" j! p
                                    7 n2 }% v3 w- W7 t( y( W' I
                    //Method - 2  N=100000  237s
    ) B2 t  O) E2 @3 A5 a                /*9 K2 X: ~6 u/ U' V
                    for (int jj = 0; jj < N ; jj++)
    . F  w& }& [3 [  ^                {
    : Z9 r' v/ h( ]# _, ]5 B" d# \                        fresult += vec1[jj] * vec2[jj];
    ; }2 O2 J# h& x7 A  {; b                }" u  M$ s' _- @
                    */
    3 k- q1 }* S  N8 j                                ; E" u; E! z# E, o! R% N& w" N
                    //Method - 3  N=100000 204s
    7 U9 m6 a! s8 o- k& o6 Q                /*6 z" e) Q/ x) q. \) v
                    for (int jj = 0; jj < N; jj++)6 ~+ ?  H3 J$ o4 A
                    {
    ' j: D' L! d- l- F0 C                        fresult += b1[jj] * b2[jj];7 @5 X7 [4 Q$ F
                    }
    / @1 R% C, q' W2 s+ R                */' ^; {' X9 q7 K- [0 V
    9 l  `" G7 ?! {0 W9 g
                    //Method - 4   202s
    ' a9 s. ?6 P2 s( a; s                /*& a2 o& N5 m4 s0 l1 m
                    for (int jj = 0; jj < N; jj++)7 N; K1 a  I5 d  t) x. ?4 t
                    {( l% R6 M. |- k
                            
    + v( m% m, I7 \5 j2 X                }
    ' G0 r5 D; l9 I5 r                */9 e" E: m/ B9 f6 o. ]; P# h
                    //comment out all methods, N=100000  202s                : m9 k: A0 P  I" J( p$ V
            }
    2 u1 B, w- R$ H
    : {+ D, b1 l; C$ T        delete []b1;
    . U+ w$ _: P, V% f1 w7 ~        delete []b2;
    0 u# U$ A  ?1 o0 P" h9 u
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?1 A: b) w+ x1 S& `2 c

    2 `. `( w0 @# L* Z; ^) `7 \你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    ( H/ F7 R% d8 L; s; A9 x) i& `3 k
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15% ?% ]! b( A3 {! b
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    * v- ~" G) q/ H! m0 O. V6 n- a
    , D( _9 H0 o2 y1 J你第二个试验里面的j在循环里面又重新定义 ...

    6 C. v& l& K6 C9 s$ P内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    * b, M$ P# z5 P% H: v2 y0 J; m/ f$ N
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    2 p5 z7 `* ?- d1 t0 `内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    $ f+ m( @6 h+ l% [% H4 k
    # z0 h$ w: C8 w: `不和它 ...
    5 Y0 {- d* M0 a  O
    2 S4 x* K- g) E1 p0 T9 [/ [  W: V
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    3 L% L( C8 g2 y后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    8 G. H! [: ?& `/ hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)8 \) @* C8 k( o; `" C
    {" \* u/ l8 L- H1 I4 k+ t5 s# }' E
            comp temp, xtimesy;
    ( ~+ ~8 q. i& u" c! T
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。0 ?% z$ h9 ^8 Q( @& L& Y" x; @
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?5 F0 E* O* s) y6 [+ k0 f9 N+ t
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-4-7 04:32 , Processed in 0.044531 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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