设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?1 l% v1 S% z# p# s5 G' S- c* G

    * v+ n" F( \. d4 R$ W- u自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    ; s# U+ i3 Y/ w" O
    8 M  G7 w3 s2 g/ Y速度优化问题真的很有意思啊。/ q* c* @- z: Y3 H3 H7 f3 L0 Y: |

    / b+ q' u9 M; A$ U& K+ s, K5 Q欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    . R. v; p8 z1 q0 g, j: X' w把代码贴上来看看?) H$ E: @5 F0 u) [
    8 [- ~- {! {7 y9 s4 |) r/ x
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 $ |4 M0 a  F- C
    数值分析 发表于 2022-9-24 23:043 }+ c0 v+ A" C' \1 I
    拉下来?拉多少?7 K' A5 g1 f. `" Y6 i
    把代码贴上来看看?

    * X' @$ T" t7 ~- v6 U9 B* }" K, D7 N
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    , ^! s% D$ l9 r' m2 y4 X5 a% g{: F/ H7 P; J; F$ P$ k- A
            comp temp, xtimesy;
    ) V8 }/ ]8 I% W        xtimesy.re = 0;) y5 u' s7 e+ j) t5 S1 W
            xtimesy.im = 0;7 B0 @# r  Q, m! L3 T& r
            int j0 = lenB - 1;
    ( r/ n/ b2 h) F3 n        int    i, j, i1, reali;9 l% }7 x4 G6 [0 |& n! E
            if (lenA % 2 == 1)% l* I- e. o& Y6 f9 Y4 d
                    reali = lenA + 1;
    , `% L, z0 S: B: a" }8 |' X        else/ b+ |. f, I9 T& _1 Y$ u. b
                    reali = lenA;
    5 T; P5 r# ]( P6 g; }3 M" L( S        reali /= 2;* s: X  Q0 _7 J- U# q

    & V4 b3 U4 c% a, M! j        int nconv = reali + lenB;
    9 B* o( ]4 {! \8 E- e' U3 M        //#pragma omp parallel for
    ) E  H* J# `% V) g        for (i = reali; i < nconv; i++)
    * q) E, d3 n; \' x6 g        {
    ) \" O+ ?; U1 X) K% h                temp.re = 0;
    7 v9 E$ l% P8 e* @- O$ g* D4 m  G                temp.im = 0;) c% a+ x: {* H, ]6 V8 Q- I' F
                    i1 = i;! x7 ^, w* @* w5 P0 c
                    for (j = j0; j >= 0; j--)  Q' K) o" D: G0 V9 K
                    {1 ~8 P: u2 v) G* R
                            /* floating date operation */
    . ~8 f# y2 X( P. V                }

    8 L+ e( \( ^; Z        }+ n; p9 G' e5 S) r5 A, g
    }
    . q! K6 B) p1 p; f" o; {/ J) B
    % X3 q" Z" l% ^3 {. Axcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    3 J  `* x  Q! O. e( w9 U9 C
    ! n: i2 G1 j4 u* \红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。/ h) t0 l2 s! Z& m: ~
    现在call xcorr 100次,耗时78s.
    0 H. [" ?; T6 G# S8 A1 W& h7 u; i/ C& m" Z
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 3 ]8 N9 l6 n) a5 P" g0 m7 c
      {% Y/ s9 M, h3 \7 e* j; H; q
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:332 R) K: J  z2 d0 ]0 r
    Maybe Debug mode?

    6 k! r! d/ j$ e( J8 e( X5 ^" @+ o( p) `( n) @# j. O" G7 S
    不应该,看我上面的回复。
    ( u' k; ~# K' r' \5 ?* \0 j4 D" P) k
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 & ^3 D9 c5 C' T
    雷达 发表于 2022-9-24 23:54
    5 k" N6 S% C% b) w: n9 U! xvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    * e1 A5 _+ X1 G: g{
    0 ]' z( V3 o# @6 p/ Y; o- C( X& L        comp temp, xtimesy;

    ; }* n% I3 _8 V( G4 Q3 v
    % d0 e: v! h. m$ T) M# l这个不是这么比的吧。。。
    ( p; V/ w+ Y5 h2 b7 c
    # ~4 N: i, A) M您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    % Q  @) R5 N+ J# a& i8 l4 h2 y$ A
    ( R4 [" W  M. p7 k+ r, [3 I3 z而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    & z  y* Z& D- f
    数值分析 发表于 2022-9-25 00:20; V! m1 o# P' O# S1 ^6 D* V9 v# k3 X
    这个不是这么比的吧。。。
    + V3 O/ i6 Z9 ^. C* T! z' Z0 j! f$ k* d9 S8 r' Z' B5 V7 Q( o
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ( u6 r* z8 N) Q6 g. ^" u4 h* q# [; l2 N
    有道理。0 A# z% o# ~( p6 N0 m' E/ G
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。- l" u) C- H3 E8 m! y2 W

    # ?( {3 M+ r! K: o; `1 h我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46/ ?5 ]/ B3 c9 i' U! k
    有道理。4 x) [# b- C5 v- I7 c
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    1 d  ~0 r2 a! ]6 N  Z6 Q  ]
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
      a& d) j, C# H( \Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:201 h  @7 `! _" X5 I9 i2 ~5 W
    这个不是这么比的吧。。。
    . o( e6 E6 H4 H$ `$ `4 y. }: X# X
    ; P9 k- c6 M; c, Z您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    3 O6 o- @/ R+ h; y
    : h  t( G: P- w; w现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 % b# o6 s2 u9 l$ E
    沉宝 发表于 2022-9-25 01:48: c8 \* N- g. [* ], A
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    3 B2 M; b4 s( p7 E6 h2 d- V8 G
    ( h1 T( R: Q$ U" W2 z  ^
    是的,兄台说的对。
    5 E, v* P4 E- g% _& X% F1 C. I2 f1 A; @) r5 X0 X# V
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    8 J3 e* E4 `' j/ O3 h2 [4 w( d& Z. z: S- L- @( H
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。' I* q; ]- }+ ^; C: M

    # x# l% |2 u/ J* F; O8 M, q6 @比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    , X; H* ?8 |+ `# H8 D
    3 o! O! i' n; g' ]# V6 @当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 ( C% e" B% i! i1 P
    沉宝 发表于 2022-9-25 01:27( z7 Q- r( }# _; R
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    8 `$ d; `5 v0 @  b& v7 T# p4 s2 F+ K4 M
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    9 k! b1 J4 v; S4 M3 d6 F0 \
    $ v- m7 B4 |% ]: Q8 {6 C' F1 n我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    . k  z$ Q# D* g( V% J又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    3 h7 w1 b# h+ ~( k7 g, G1 r) b
    时间差一倍的结果可以接受。4 @1 _+ S3 }. _& ?) R% B) [' K

    : _; v* Y, o& A+ t( d+ b0 Q# H% s7 {, P你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    ; l1 }) r7 k9 A) ^+ x
    雷达 发表于 2022-9-25 04:47
    $ J+ y6 Q0 Z' d" i) ], j6 S又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    8 z+ b  L- M6 |+ U; Z
    8 D& `2 z5 W, ?5 q( W: \$ l- H

    : L" n( J" E. |8 O! Y
    9 U) S2 ^' M; _: l能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 7 G, R% |$ W; U8 ?8 x, ^( }* n
    数值分析 发表于 2022-9-25 14:58% s2 D3 `7 i5 p
    能不能把这个也贴上来,看看和上一个有什么不同?

    1 z7 I, P. e8 C# p& b理了理思路,重新做了一个测试。
    $ o* e/ j8 M7 K5 I做了两个 vector 和 两个 float *, 都长 100000
    + m+ l( j  g- n$ ~3 H- w! G+ h) D外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache./ y* K" E! |& ]) ^) A9 _
    " h2 |& {  q8 \1 \* z
    内循环试了4种方法,
    / M2 C. \5 t7 Q# W! x! g. k1. 直接调用 vector inner_product 247s
    " d% r! f* w2 q( Y* b' R2. vector 循环点乘累加 237s* O2 D3 Z" }- @3 I( D& C4 ~' }
    3. float * 循环点乘累加 204s
    9 e3 Y1 A. C7 l. A  k) ^8 Q7 @4. 空循环 100000 次 202s# ^+ L& P0 U6 {4 j5 o$ y

    $ @$ `+ t  v; L1 P% C) L! [7 M不做内循环 200s/ e9 s6 S( q6 Q% I; g" i; m
    7 V' m0 n. V2 P/ Q
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    , h; L5 K6 y- ?1 [$ y% s. C另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。; ~+ J- d) J  g5 h0 X; `, O6 t$ K
    6 Y' z2 L3 G& q
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    7 L4 G  A. Z" C+ m" z$ F+ _: D: W. j% k  L
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)7 S8 a* C1 T. \
    6 u1 a/ ], ?! j, S0 k8 l- k! i
            std::vector < float > vec1(N);6 Y% b/ r  z  {6 t1 L' F9 [
            std::vector < float > vec2(N);3 J4 h" v8 i7 e. t% _/ Z
            float* b1 = new float[N];
    9 ~  ~3 h" s* K8 C) }: Z% l7 S        float* b2 = new float[N];; g( U" `4 R1 F% ~% e# c

    ( |- Y: R. |# Q, q        for (int j = 0; j < 6000; j++)
    3 g8 N: M# K- }/ w+ C/ B        {' Z& O; q( P, g$ I1 T
                    std::generate(vec1.begin(), vec1.end(), []() {' j, N4 I' A+ c, Y6 X2 h  T! O
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;& J8 N4 a- B7 g6 }
                            });2 z% p2 m' D; T3 ]+ G6 f

    , V! J9 R8 p0 ^* S- f- h                std::generate(vec2.begin(), vec2.end(), []() {+ E7 c' t* H* O3 O! Q
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    , f5 H' u3 @/ I1 B" H! f* N# t                        });
    " |$ X+ S; O3 q; p3 a$ E0 X6 L2 B  S2 E5 N5 r
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    7 R: S3 E+ y' b0 x" ?$ p2 q* O3 n                {
    & q3 N4 s: i. v' j4 h                        b1[jj] = vec1[jj];
      H* Q2 x2 Y7 Q5 g3 B) c$ n                }8 `* G0 |) \+ x

    3 n5 X8 a6 L5 d$ H- x                for (size_t jj = 0; jj < vec2.size(); jj++)7 z5 ?+ }  u1 d* v
                    {
    3 c0 x6 C2 T# s. T' t+ |( m  S# r                        b2[jj] = vec2[jj];
    0 G: [) X1 L- ~9 O: v                }6 q; s: E& {" e( w8 N& R
      D4 p% V" n% X$ p
                    //Method - 1  N=100000 247s  : g: O$ K  S3 ]# @8 T8 f+ F
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    " |( h3 g* \1 g# [( L                                
    : O9 Q& C, K- i' p% |                //Method - 2  N=100000  237s
    ! V9 ]! J: {- I+ `# g7 R  F1 a# P9 X# \. _                /*
    % Y/ _% v# l2 o3 B  [4 Y7 K+ e! E                for (int jj = 0; jj < N ; jj++)
    & N3 `$ m; E& g4 c! R                {
    6 m7 ~# {# F  @, X% O" P) S% S                        fresult += vec1[jj] * vec2[jj];0 R$ N* `! c/ r7 T0 z4 ]
                    }6 \3 \; {" h. w9 V! W5 ?4 c; P
                    */2 c; m7 h3 F& o8 H, K
                                    : l( V! ^  Z0 k* c, c. d. e
                    //Method - 3  N=100000 204s
    5 [8 [9 \8 ^# H: @                /*
      }1 O; f2 C( |" i. M3 a                for (int jj = 0; jj < N; jj++)4 f' b3 [0 K/ `% D3 @
                    {
    ! E& ?7 W" J7 q4 W; I                        fresult += b1[jj] * b2[jj];' L) b# q6 C5 B( @, D( I  B
                    }
    3 U, Q, n( }9 E* [4 u8 b+ [( b+ E& p                */
    8 ?5 e2 }/ |& I$ `* ?1 ~" C% |0 S- a* F8 {4 w# X% K7 T
                    //Method - 4   202s/ V6 A8 e( b; |
                    /*& C0 k/ q6 ]) V
                    for (int jj = 0; jj < N; jj++)
    , k  x+ h# ?) J' ~( c! K3 S                {
    " q! _$ V. E7 ~1 ]                        6 G' O6 ], ^0 P1 E5 u8 P2 `6 S! o
                    }. N( M+ x) I$ B0 w$ c4 M
                    */' T( Y7 w/ a$ |3 A& Y
                    //comment out all methods, N=100000  202s                0 f# Q# X7 v  i: ^( J
            }
      Z7 _: t& U( |, _1 L( N# H" s4 U8 h5 l. D6 N1 i- }
            delete []b1;5 Z, Z, z6 W7 f, l
            delete []b2;
    ) F, A6 }- U% H; B3 F
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?' e( V- ?: m# `1 n
    - r$ b, \" o  N9 Z9 T4 X  p3 R
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?& e( X4 c1 [0 }$ Z
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15  p. M5 o1 k+ m
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    1 ~  V3 X* A3 p+ b2 p
    1 o+ v- d4 E. S0 }你第二个试验里面的j在循环里面又重新定义 ...
    : F9 X) E. M6 w8 S
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL3 U+ C8 w: U* m: c# W9 W
    2 N# E8 j- K3 H; V
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:161 Q. U6 J: w: ]( h- Y4 }
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    7 O9 P" G4 L3 k/ T9 d- i! w, c! I+ s8 `9 i
    不和它 ...

    ! C4 P/ {* Q5 x6 U( f% p( j# t! G! M* h. r* R* A% {
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    1 r9 \* x! m4 A# u后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    ! E& j4 I3 t' y" {, a$ V5 S- Jvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    " f, a6 R: t: X{( B3 Y% G) P  l7 u) O' v6 b6 N
            comp temp, xtimesy;
    ! ~4 o  z8 a; `' e
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。8 z2 |" {" X5 a" N! H
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    # f6 r/ P# N) n2 Q0 k0 ^/ sVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-12 07:52 , Processed in 0.053900 second(s), 22 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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