设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?  Z6 Q2 ^) ?: L. A. j% v% o

    : H9 O/ |) {7 c7 Y5 ~' q$ g' k自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。" l6 }9 A" D% j/ S, x% v
    6 a/ G0 y, h/ g4 ]0 B7 A; w
    速度优化问题真的很有意思啊。# r8 ^: s7 I. |; H2 e
    & Z. _% J# T5 L
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1930 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    3 E& R5 q" t- Z4 Q; e把代码贴上来看看?  V0 v& }, Z* S5 K: j" S. o% ^
    ) F6 `) j1 t- c% z9 _
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

  • TA的每日心情
    开心
    2025-6-14 10:13
  • 签到天数: 124 天

    [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 编辑 8 _1 d7 z% `; r& j& u7 r
    数值分析 发表于 2022-9-24 23:04, v4 b4 Q4 V3 l0 n2 w' l* h
    拉下来?拉多少?& H) C" A& Q6 _. w
    把代码贴上来看看?
    0 K. e$ c) B5 C9 A, b% A+ v

    ! K5 W! d3 L2 [  D5 Z% {void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    2 e3 n: u& S  e0 T5 r{! Q/ x( q! z, i' J0 s
            comp temp, xtimesy;
    ! ?2 q7 B& w& i! M9 \% ?        xtimesy.re = 0;4 B: x$ R# C1 ^5 M
            xtimesy.im = 0;% F6 k( [+ X/ o
            int j0 = lenB - 1;
    0 O# S/ K" R% ?& x+ q, B" [6 K        int    i, j, i1, reali;
    , C% K; B, h4 m2 p, k+ j1 K        if (lenA % 2 == 1)! H/ J7 r" Y4 h, M
                    reali = lenA + 1;
    9 n& J; P- r" O4 D3 A6 w        else& W1 I1 S% ], w* ?4 t' F% I
                    reali = lenA;
    1 S' C1 L6 ~3 w0 [7 Y, o        reali /= 2;
    1 O6 ], b+ X  l0 I, H' ]2 r/ T+ c+ n
    ! r1 |9 ^0 w% m+ r( l, `7 j0 |& i        int nconv = reali + lenB;
    ! }  K6 A7 I/ C) w        //#pragma omp parallel for
    6 S& p  E# G3 M9 w8 W9 B+ m, ~        for (i = reali; i < nconv; i++)
    # Z9 F! O8 g( a5 v! N( `7 l% _        {: V, b9 t6 K3 q% _# t% k. r. i
                    temp.re = 0;
    4 _4 b5 v1 W) d3 G% U% d. c                temp.im = 0;
      o& U! n" J) `" ^$ a* I) G                i1 = i;; B" C# v! Q# L1 u5 \: N. v
                    for (j = j0; j >= 0; j--)
    % Q( k4 t. B$ w: a& l                {
    ) K6 @9 ~( l) N; o( n                        /* floating date operation */3 h' |$ B/ _7 z6 H' U8 N9 `( z
                    }

    ) a, X- F3 r) ~7 b/ U6 }# ?$ M        }
    4 d/ U) w$ K8 Q" Z  X}
    $ }* H% K  P( P+ A9 J! _
    / S* G  d7 B, ^xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样$ j7 b1 m8 F, ~% S% k) v" F1 L; K
    2 q2 @1 d# l8 E, \( K
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    : Y0 O* b6 @2 ?. v( \4 ^现在call xcorr 100次,耗时78s.
    5 O6 f4 _& {; X6 K: @& p. t- ~$ d3 F& t
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 3 \7 V% l9 X% {
    % @9 v3 V5 Q2 a9 O; _( p
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:332 K7 Y6 M( G& A0 w4 h0 |
    Maybe Debug mode?

    " K" r1 p( k4 b; E0 z3 n
    & D) @# W+ Y* m& k+ ^不应该,看我上面的回复。" _+ s2 L5 H4 W( s2 E
    " t: h# A! L9 S0 `
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1930 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 & X  @0 a4 W/ f- Z' G9 @, M/ i' ]
    雷达 发表于 2022-9-24 23:54
    - I. p8 g3 A. b2 R0 v8 |void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)8 f3 ~3 B7 j0 W; O5 _- c: @
    {+ M+ g' C8 S6 @/ @3 t
            comp temp, xtimesy;

    " N) e1 r" {4 m! a# e# y1 _
    0 H+ r# M4 G3 l$ k这个不是这么比的吧。。。
    - _0 P0 ^2 i$ J: O+ G" R8 c: v- }6 K" m
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。/ N! A5 S; G2 r8 Y8 i
    0 N* O5 _+ ~8 X+ q
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 / V* p2 \. t. B2 B# j
    数值分析 发表于 2022-9-25 00:20
    2 `. |9 _  {0 L+ ]( a) D这个不是这么比的吧。。。; [7 `4 V: V/ o0 {% z: J% y
    0 s! U6 p4 v8 _# P
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    9 y0 U0 J% E8 f/ A1 j7 M. [, k% V) j/ q+ c
    有道理。
    7 I) ^5 Y5 r5 o" s; R; X$ A8 t# |所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。) c/ ]/ p& C$ ~8 U% q( C

    - @, t8 @! r: r5 m5 g$ ?我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46( Q  ^. f' l- [
    有道理。& `  ~) e9 x9 w* ^& O
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    2 V! J6 j+ i& T
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    - J+ V6 z# z  U, W+ W. k" Y+ dWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    5 c/ t; V2 g) M- N0 Q/ Z这个不是这么比的吧。。。" A; A8 r) E1 i2 S6 L/ G

    6 h/ C* u1 `2 E4 g3 s+ x您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    ) x, k9 q/ t# h% R# p
    ; ]. A, l# j# O/ {9 P( }  s1 G2 K/ {现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1930 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    * m) u) H% N6 m: [: P' h
    沉宝 发表于 2022-9-25 01:486 A- t8 _6 H$ r5 E
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    7 S4 s0 b# E# u2 n" |: |& M* v+ k" ^) ?, ^% g4 @7 I: b
    是的,兄台说的对。
    2 J& z  z* e5 W& Y* r
    * U  V* D2 u. u. t其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。: ~/ j, ~& N, {1 N6 L8 Y
    5 u8 ^. w5 s3 L# l5 \( X+ p
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    6 [* |- C! I: m0 ]" G5 y$ l  x+ n) R$ x" L9 q+ C
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。; w* S- d8 G# W- f. ^% i/ S
    $ ^; v1 m1 d: L; o
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
      m! w- H! H1 S7 s2 c
    沉宝 发表于 2022-9-25 01:27
    - v6 u% c6 ~2 y( N* c+ i! _2 M1 L你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    ) y' `; [" l) ~1 J" A
    2 w8 s% W  V& F" t0 x
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
      u3 Y7 ?  ]4 n. f. Q: n
    % c# j- A, x  h* s+ o我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47$ y/ K, ?8 c' u( W
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    7 O& Z) z  q2 i: R. {时间差一倍的结果可以接受。# V3 F, s! A9 _5 B& X. `5 E' p2 F

    5 l# Y5 F: e' _6 l8 E+ Y你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1930 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 ! f( W# S5 V$ b+ e5 q; n
    雷达 发表于 2022-9-25 04:47' {8 o7 f( ^) W: W* B
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    $ m% [% z6 _* o" X3 Y5 [% Z' u

    5 z+ j; U4 M$ M! R' r9 j
    . q1 w: S$ \2 Q6 P$ ?8 d
    ( d3 U" k% w0 S1 a7 o9 L4 _# x能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 * T4 T2 m2 S2 p( E
    数值分析 发表于 2022-9-25 14:58* A% W4 f; U6 q: f9 n) J" e
    能不能把这个也贴上来,看看和上一个有什么不同?

    + ]0 X: @3 f& G理了理思路,重新做了一个测试。# A0 Z" ?2 g' T9 |1 c$ g: K5 a
    做了两个 vector 和 两个 float *, 都长 100000
    3 i* h' H; t* Q5 n* m外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.( O2 m  Z8 A& r% }
    7 A- N, u: L& x+ R7 Y
    内循环试了4种方法,
    ) N" V* g' t# A$ b! }4 }" S1. 直接调用 vector inner_product 247s 5 ~! Z3 a; G% A& k5 ~: d6 x) G
    2. vector 循环点乘累加 237s  c" D7 q: E# F% \
    3. float * 循环点乘累加 204s
    7 S/ {: P9 O7 I1 t4. 空循环 100000 次 202s
    , g6 U" C) ^) d' {0 s6 E: ?
      @+ p1 N7 X" X" q5 H不做内循环 200s% b4 Y% Q' L. C, n: M- l6 n

    ( o1 y8 j; `( b8 M8 |+ j你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    6 `: H6 B. A- Q, D& x! a; U另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。6 j1 R! l& V; p) ]! K2 }  J8 O: n" p

    0 R! `) R1 Q- N至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    1 c3 c  b% ]- l: R$ w& z/ s" u7 {7 h/ a# D) Q, n% Z& u, n
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    / U2 i# F; `( K/ {# i- f2 f! a5 e/ |( r
            std::vector < float > vec1(N);- R; T3 q$ A0 o, E' @. |- }
            std::vector < float > vec2(N);( S3 o$ L! M9 f) N
            float* b1 = new float[N];6 `+ r2 J9 I/ t3 F( d2 E
            float* b2 = new float[N];2 S0 e) e' n  ], l1 @9 g! s" O! y' o

    + B+ E/ s3 G1 {( t9 m        for (int j = 0; j < 6000; j++)+ ^+ i, Z9 E/ }# l. h2 h: N" t
            {4 G% s) X! |) u
                    std::generate(vec1.begin(), vec1.end(), []() {
    7 d0 ^$ v8 C; X' O, u8 u                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    " P7 N3 Y" C2 C' U' L' J( j                        });6 t* @+ a, V2 o5 K1 {8 o% u

    & G$ h% Y  u& ?0 z9 m3 x                std::generate(vec2.begin(), vec2.end(), []() {( L( g. i" v! u" D! P2 V. I
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    . g/ G8 b6 w2 \3 P3 y                        });
    , U1 D( ^- \+ P* Y, u" `  b' h
    8 R+ I# g( C8 u' T7 V7 }                for (size_t jj = 0; jj < vec1.size(); jj++)
    ( c; `) D& t6 u/ w                {
    . k* C/ V  }1 U- I                        b1[jj] = vec1[jj];! U  F) H' L3 ?
                    }
    4 S- M6 r# W+ m  p) E: V! e) B, {" V: c4 q+ @6 @7 z. N8 L8 w
                    for (size_t jj = 0; jj < vec2.size(); jj++)
    6 @! B; s6 K1 T4 N3 E                {" A* n- V% O& A6 N. a6 |( l, K$ S
                            b2[jj] = vec2[jj];
    * }& A; a8 X, X. ?                }
    " W% F! _7 E: Z2 V7 ~  l/ c# p  a' F$ j* i
                    //Method - 1  N=100000 247s  
    & O; n/ c+ ~- c5 t& z                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    1 c: `8 O$ v3 A& [1 z: W" L                                
    2 G8 N; h9 F/ a% h! r                //Method - 2  N=100000  237s
    5 l9 e& Z  z3 l# F0 N6 X                /*" O5 ~9 ]. T9 j- m( O/ ]
                    for (int jj = 0; jj < N ; jj++)2 C/ M  c: k% B$ e
                    {7 g' u- d$ r( \5 A
                            fresult += vec1[jj] * vec2[jj];8 o8 m5 Y9 q/ w
                    }( D) ~! V1 y# H  ^
                    *// a4 ^, q! f8 s  {- ~
                                    
    ' O1 ]. {5 E# v1 ?6 G+ N                //Method - 3  N=100000 204s. Y9 l* I6 M/ h
                    /*
    2 I5 y; o: _1 {% X0 ?! @; B4 w3 ]                for (int jj = 0; jj < N; jj++). q2 e, h. Y9 j
                    {: e; e6 q2 h% V* I  t0 T
                            fresult += b1[jj] * b2[jj];
    # d  H8 e; i  ]2 s+ c. x$ Y                }
    0 `" J/ d) I' V8 d# @, y                */
    - N9 M8 z; R+ x# b1 X! z2 b8 e$ G% a, s9 s3 {5 y( \& M5 [9 f
                    //Method - 4   202s( g: V4 ^0 ^, F/ z% o- p  D" H
                    /*5 m' _! g) b4 @
                    for (int jj = 0; jj < N; jj++)
    ! c' P6 l' n+ v& j* }9 Q" b3 A& H                {6 k& o5 I  ]4 k, r) a( v
                            
    : \" _- U* h' d1 Q" H' @                }9 O; ]7 N  ^7 w2 D
                    */& @1 Y) b! i' |4 v& k- j
                    //comment out all methods, N=100000  202s                3 q5 X4 |! k, r
            }+ w/ `0 |; v4 b' j3 C. ]
    1 N0 ^' ~6 e6 [* a, C- o  ]# \
            delete []b1;
    $ D3 c# C7 \% `, U$ s* `0 l# G        delete []b2;

    4 d0 L7 i$ f5 m
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    + p7 \0 S; l8 J# D9 l( Z: v9 ?. J& G& P- G
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    $ F5 E; v8 J2 H. A
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    7 H( G& o  X7 E( \瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ; x0 l5 D7 y) U% u$ ^+ u0 b& ~6 a7 a5 H
    你第二个试验里面的j在循环里面又重新定义 ...
    ! y; A- [6 L) C, @7 P4 f# l
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    0 g, o4 X. b+ q; f8 J* G, V: X7 B: G0 d/ C
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    5 X' P# ^' a; [% u3 u内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL/ J+ [5 m  ^5 i# z$ P" |  ^
    2 o" ]) `, \1 @3 P
    不和它 ...
    ; `7 `* J, y$ v. O+ f+ a2 H  a
    8 w6 a. R, H* h1 S
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。; a8 `: e0 \% K& U: e4 p9 A, D- A
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    , \8 u# K, |  L% u$ qvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)0 Z9 z& A# S, `; o  X
    {. K' I$ C/ }1 P8 _. P6 `
            comp temp, xtimesy;
    7 c7 Q' E0 Q: [! S4 K
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    0 L4 ~7 y. f7 V% C9 ^& G$ o7 c内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?$ c, f( |6 T# K0 w( d
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-11 09:10 , Processed in 0.057631 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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