设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?* F, B9 W  O8 e4 S( K

    ) z! H5 g% z1 c% v1 R自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    8 g! R9 d$ v* ?
    ' F1 l) {9 F! N3 w速度优化问题真的很有意思啊。( O1 {* y( K1 z7 r! e7 y
    6 |4 o3 j( D0 m
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    8 l8 t8 J. N3 ?0 k把代码贴上来看看?
    ' S. z3 y9 p3 G  ], n5 P. M! {" s5 C: S+ b& J, S7 \1 q& k/ f
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    ( F" p2 Y5 L2 k$ h
    数值分析 发表于 2022-9-24 23:04
    ! P8 [1 b  c9 y5 j* n0 p' s! T1 c拉下来?拉多少?
    : [& d6 X! h5 m( f' Y  l+ Z1 ^把代码贴上来看看?

    & r. [* a* [: T0 c2 |3 y( a/ Z& R
    + x+ ^9 R3 x9 E) S, [, Qvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)! j- L4 _6 P: X; e% t% [4 ~
    {3 K& T4 E' r8 C' s" v. E) }
            comp temp, xtimesy;0 g0 j8 ?- S; K1 j: [4 ~
            xtimesy.re = 0;
    7 b8 k$ \$ q- @" q' ^( C0 s        xtimesy.im = 0;9 a3 t3 F+ D7 ^( k; ?2 e0 g, C
            int j0 = lenB - 1;+ y9 s* k& }0 C$ Y/ T0 X+ V
            int    i, j, i1, reali;$ @# d- A0 F0 x. f. C
            if (lenA % 2 == 1)
    ( R+ m, [# ]9 v; L. f* G                reali = lenA + 1;1 f  C  Y' ~& D7 C* c' d& j' m. I4 [0 |
            else4 {$ }; D; ~7 F- p3 q" g5 s% [7 \4 ^
                    reali = lenA;
    * f: I) y9 g" J) x3 [        reali /= 2;
      T5 o3 F/ ^* {2 P
    1 x" r/ V" ~# Y$ z7 ?7 ^& P        int nconv = reali + lenB;7 U4 m# F9 `- `2 W' ]2 a
            //#pragma omp parallel for
    ' E4 Z2 {) I8 m. o        for (i = reali; i < nconv; i++)
    ' G! Y# @( D& @9 \2 P        {/ n5 I. v. t6 e5 {) Q
                    temp.re = 0;
    & \+ T* a; P1 `  a- O% P                temp.im = 0;! H& k! p: {& ~! |, h8 k5 Y
                    i1 = i;
    / s7 g' y6 {7 G5 }2 W7 e/ T                for (j = j0; j >= 0; j--)) k7 a6 [% I: t& ?: J
                    {) c7 t1 C" b0 z5 N1 L  s- u
                            /* floating date operation */6 Y- O; v* I5 r
                    }

    . t0 R& ?5 q/ G" w2 r        }# L9 h2 \4 r6 P. V. _
    }  d. f8 [7 B0 [8 {/ V

    ( e' B' s9 [6 ^0 b" }/ B4 W% v' _xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样  V- T7 U# w) a. x' B# I$ _" k
    ) C+ O: [1 z: J6 p3 c
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。& l9 ^. a0 m. {3 ?  e
    现在call xcorr 100次,耗时78s.
    9 I, m  x$ G4 d# g' u, E
    % w! K, n1 J0 |4 ~- R* }& o  A如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. ( w8 P" ?$ A3 A2 G- A9 [3 h( a, n

    ! s. P; \! x5 c; B4 S  r& Q# |. {2 y
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33& X, e7 O6 X* y$ P. Y8 _4 a* x8 F  k
    Maybe Debug mode?

    0 s/ G5 T. R0 P7 k/ o6 H
    , b$ S$ p) V; }% b3 g2 m0 s不应该,看我上面的回复。
    - E% w; |: r1 j: }
    ' _3 i4 e4 ^1 t3 l% i; r( @我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 + R: `2 w0 X' ?8 ~4 Q6 s% Z1 @; v
    雷达 发表于 2022-9-24 23:54
    $ H. ?7 }; ^& nvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)# \1 K4 p! k/ u* Z3 S  ]: a  p5 T# @
    {
    & z7 ^0 r0 \' t  l& n- ]        comp temp, xtimesy;
    8 W( C( f/ J( w8 T) B

    ) b* Z+ u2 c6 U7 P, n这个不是这么比的吧。。。6 V: L9 G5 }+ T# Z6 ?8 t8 G% N
    % t2 t( f8 t  w6 j/ O& z
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。5 y. l7 V+ A7 ~% Z/ @5 |  _1 f, j
    8 N* {- U; H: a" }, ]# 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 编辑 % \) l! D! q  z9 {  J, R, C
    数值分析 发表于 2022-9-25 00:20% i2 D3 ^2 R4 V
    这个不是这么比的吧。。。. Q% j5 G% w5 X4 p3 O: e( Z
    ' c, ?# \' {, }$ u' {3 \/ D
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    . M2 l) f3 S1 p2 P( X' F) V% x  R0 w
    有道理。
    / q! X; B' G) x所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。* i; @( \( i7 S3 C& D+ ^( N) o
    8 O: X7 E2 i/ \2 M
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46, c+ z, S2 T6 A2 K6 Y
    有道理。0 ]+ P8 F7 d* |$ S% Z
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    4 x6 L; E# F5 K# ^* S8 N9 l
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多; m# t. m. F6 I5 I- l$ [  K# r
    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
    ( Y( @0 e0 B" K" K# R' C* o  |这个不是这么比的吧。。。3 m- t, A$ Z: G" m
    4 p  c6 E' G3 ~6 S' f( Z0 J- O
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    % R- M8 O1 @( R! h. a, r
    % m  Q8 P2 q0 G2 O" Y  @现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 & m: B* j, X( T/ M4 {
    沉宝 发表于 2022-9-25 01:48
    % U6 ^( l/ x5 ?, M. w现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    4 V) K" A5 c+ ~, H) a0 G
    % w9 d- H9 m/ f是的,兄台说的对。
    - J, [  M& ]  D) ]2 K2 M- W" z: u8 `$ ?9 a; f
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。. A6 L2 K' v+ W* Q0 s, H* |! L1 Q7 l

    0 Z4 w- q8 b# S4 i, S9 C$ K雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    % c% U2 w% y1 J1 y: O% E
    3 i( C- p4 W) o- {/ H0 G比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    9 g$ I2 @  q, Y6 [4 z7 t, V" C: X! x& B% @2 J) U
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    7 R4 b7 y2 k, Z, b& Z' u
    沉宝 发表于 2022-9-25 01:27
    ) K0 m) u' ?2 d; V6 u* H5 B) z你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    & o4 T! G- N6 U

    & M' Z5 V) L% |( s- x又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。; }+ ]# k: P9 d, A/ \

    3 f/ z# x: v3 Z8 B3 x我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    + B8 e: x- `  K4 N+ _又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    3 T! S' H) u& A% Y" @  ^时间差一倍的结果可以接受。+ L7 K! \" g* q. }
    + A& \3 K9 A  ^2 w
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 4 y& T$ M( D! Y; l( z. Q/ N
    雷达 发表于 2022-9-25 04:470 F! O/ n7 U2 ?/ S
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    + b5 y6 g6 y6 r

    ; T" C" [9 p9 Y/ E/ z/ R# Q1 g  N# y8 C4 ^# C6 a

    / A7 N6 F  d1 m. G能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    * P( C3 z$ q8 n" J! m8 i
    数值分析 发表于 2022-9-25 14:58; h# D. L' ?: T1 _- R: Y
    能不能把这个也贴上来,看看和上一个有什么不同?

      H- O9 A# K! C/ O+ t理了理思路,重新做了一个测试。
    $ F  F9 s8 d& g, Z8 b4 j5 }做了两个 vector 和 两个 float *, 都长 100000# ~4 ^2 d, \, e. f
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.5 A" \2 s7 l& H6 h5 r* H) G- e

    / `& H/ l$ G' X- p% e内循环试了4种方法,* k7 Z" X% g8 T8 l% K
    1. 直接调用 vector inner_product 247s
    8 k- F8 E5 r# w9 a0 @* H2. vector 循环点乘累加 237s+ }$ |( o$ y# ]- D- o
    3. float * 循环点乘累加 204s
    - B2 O) b* [* f" V; Q+ S4. 空循环 100000 次 202s
    0 z8 _  q, Y* X. u7 L1 K4 A; [" C* ~& O  p# S
    不做内循环 200s1 F; ?& z9 Y" b" c

    0 V+ b$ Y0 t# {' T7 n6 V% f你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    ( N' f, R( J+ G4 [% ~8 R另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    - N7 d9 z; k& v$ g  I: a" l
    ' Q. G! L$ I- _0 ^至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)6 e9 D. J$ ^. q+ E, H2 U
    # y  i( V( s2 C0 G9 K; B7 m9 o
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    1 o6 R, |: R0 W/ b" V
    8 ~; N$ Q7 B4 @$ A
            std::vector < float > vec1(N);
      e4 l  q. ?; r: P        std::vector < float > vec2(N);
    . W2 q: f) o. h/ Z9 J        float* b1 = new float[N];
    5 V& U; w2 |9 D3 z, Z9 {        float* b2 = new float[N];- i* q$ i- f2 n

    , v6 A2 N$ g$ W  W+ J+ M        for (int j = 0; j < 6000; j++)
    5 ~% m8 B. u1 `; q7 q6 w        {
    % A8 @' b5 {! O5 _+ p' |                std::generate(vec1.begin(), vec1.end(), []() {
    * C0 c- |& P1 A                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;2 b0 [  s' j7 l' b. z! t; _# z
                            });
    ) N, D! b/ z5 V+ ]4 q$ h, w. O. I
    # D- X8 W0 z: F# Q( E  k                std::generate(vec2.begin(), vec2.end(), []() {7 k1 v' m4 o$ U$ y
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    1 s3 d  M: f) a* @( H                        });$ {8 n4 D  }) v% s8 i9 v  r* [

    / C( d# m5 t$ z# e0 H9 j4 M                for (size_t jj = 0; jj < vec1.size(); jj++)
    : M0 T: H) j% q4 @* R; e1 }9 ]! U                {' t2 @7 u# v7 p' A9 v
                            b1[jj] = vec1[jj];
    * `: h. C3 S$ R                }8 M) ~: i+ ^  V# w2 C

    7 r+ U$ N0 H, B6 t) L                for (size_t jj = 0; jj < vec2.size(); jj++)
    0 s6 x1 ^8 i' f9 r* h  P                {% Z% U! J2 ]) z/ {$ O
                            b2[jj] = vec2[jj];
    9 O2 c; G) z; i, M8 _# }( l5 Q                }
    : d# P& Z$ m$ k7 F9 ~' x, ^$ k/ l0 f" v4 }3 d& D
                    //Method - 1  N=100000 247s  & n5 y& [, @. w- P  n
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);; Z! q+ W3 ]$ ]0 B  ?: U2 H
                                    ! P6 y3 Q+ |7 I/ I. G# j
                    //Method - 2  N=100000  237s+ E) H+ q4 ^& N- E1 @/ S
                    /*
    6 ^  {7 d) y/ O, F                for (int jj = 0; jj < N ; jj++)% i6 K: F9 r5 @9 b" w  g. C
                    {
      G3 o& [: N1 T. G5 M0 N                        fresult += vec1[jj] * vec2[jj];) M( h6 q. U% T, Y6 P, {1 z. q1 R
                    }
    : W1 D) d, E- z. D) T* y                */7 S) \. H% _2 K& j
                                    " w: \1 W' f' ?' j9 q0 O5 S& Z* v7 {
                    //Method - 3  N=100000 204s  i) Z" m" y/ o) a0 B( m3 q
                    /*% h# \/ m3 i8 j# _4 E
                    for (int jj = 0; jj < N; jj++)0 ]/ e1 n. C9 i( m: {
                    {
    ; ]1 R% C: |' ]- J                        fresult += b1[jj] * b2[jj];6 m) r  t7 h% Z' P6 s& @: D: ?
                    }
    4 U$ L8 i3 p+ {/ f/ I4 z                */
    8 B  Z  S, @0 ^
    ) j- ~* K& a; D! e                //Method - 4   202s
    4 |( K! W9 v+ \7 O                /*
    4 Z; j( l: l. P3 A0 L                for (int jj = 0; jj < N; jj++)9 l5 f; j1 N: K1 t: ?- d! R* F
                    {
    6 w3 r& `# P. f" R3 ^; d                        
    * w5 @: z1 e+ m                }7 D5 `( y/ C9 Z& o
                    */
    2 m$ u6 @* q4 L; ]2 ]) ^8 Q; p                //comment out all methods, N=100000  202s               
    ; H# o8 Q9 M# p4 j+ f        }3 h, O9 |6 ?1 T' u
    9 D. b. |$ j. \: n$ ]+ v
            delete []b1;. k/ \- y) B0 W* S; j( g
            delete []b2;

    5 B. w! c  [8 S" @5 `5 u& V- ^
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?6 e* g) d. |0 n2 z3 x
      b- a% T. g$ b' b( o6 @/ Z7 c; K* m
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    7 R' Q- U* F3 X) X. Y, I/ H
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:150 S) b* h; D( B# R/ @6 Z3 G
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ; \, @& E) j: L! X
      s2 x* I* g$ t; @' |4 i你第二个试验里面的j在循环里面又重新定义 ...

      K- z; \6 j" i0 `( b内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL. T4 ], E0 [4 L; a1 K5 d/ ~5 v
    3 a4 m2 E' {3 P, P) ]3 M
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16: A$ d; y% I: T
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL$ T  p7 b( V$ c! D8 Q

    2 w) \( D% E( M6 o. b( |% i+ J不和它 ...

    , e3 E$ K( k% P6 m( r. D( [% I' `9 _
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
      l7 |# W# c  r# J/ y4 g% @& E后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:543 C' @$ x9 j5 Q2 x' {
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)/ Z& }+ m7 ~2 V1 Y5 t" a3 Q( W
    {, P0 R/ O1 i4 r! R) @3 `6 D2 _
            comp temp, xtimesy;
    ! H$ ]! t8 N/ `4 ~7 {5 X$ n
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。+ I/ r9 V2 ]; B  q: N# m' S8 Q0 v6 m
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    1 u1 h' f# b  g8 j; dVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-27 07:15 , Processed in 0.050793 second(s), 21 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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