设为首页收藏本站

爱吱声

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

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    " f9 n* e, Q+ E! r$ [9 ~( \8 b$ `% G
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    7 j* U4 q/ |9 G" ~
    ; C/ y- Q5 k+ U/ b& u速度优化问题真的很有意思啊。
    , q2 D2 ^! `" v3 i% G
    ! q; v1 U. B. P4 Z  K欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    前天 22:23
  • 签到天数: 1950 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    $ e) ^9 b; a2 ?* x) {- ~把代码贴上来看看?
    / R" w% O: [, H1 y% z
    * s4 a: |# a6 K3 E2 Y0 e难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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的每日心情

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

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    $ k! P1 d" z, t; b
    数值分析 发表于 2022-9-24 23:042 Q1 W8 q1 H/ r( y, b
    拉下来?拉多少?
    % h  ^9 L, ~7 V把代码贴上来看看?
    , ~$ I, S, z5 p. p* ~  Q

    # _* T- u: T8 t1 kvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ' r2 u' G4 E% X+ ~# w+ p{" K# A# X& a; ]2 d8 S+ _5 P& X
            comp temp, xtimesy;
    7 z3 Q8 P  ?2 q1 a6 w6 N        xtimesy.re = 0;
    2 X" c" h! X0 _, {9 E% {        xtimesy.im = 0;
    ) i5 d7 H3 @6 P1 @1 I  ]        int j0 = lenB - 1;
    & b/ C8 G" ~& I: n        int    i, j, i1, reali;
    % X/ @$ ]7 r4 w: a2 K        if (lenA % 2 == 1)7 K9 `+ u9 ~/ M" m5 V6 A; e
                    reali = lenA + 1;( E5 z, o0 V( m5 P" \* l
            else
    # e/ B/ H+ `: h' `, l                reali = lenA;
    8 m" c" N* ]! u( z5 E+ U        reali /= 2;% R# a# J. w3 j- v: ~7 K8 |& K

    " J% N7 k. A9 I1 m- w; m        int nconv = reali + lenB;9 E/ a: ]3 K* X- C% p0 B2 J$ [
            //#pragma omp parallel for
    ; X! l; X, f8 K# o& Q9 _        for (i = reali; i < nconv; i++)( n6 o$ f6 L+ a
            {! I. n- O9 {7 v4 n5 J
                    temp.re = 0;6 F  s0 n- D! N+ C5 {0 Y! @- Y7 _
                    temp.im = 0;2 q5 b0 h+ u2 ^) ]+ S" z8 w# h+ k1 ]
                    i1 = i;1 o4 T+ _/ T; K: V4 F& s
                    for (j = j0; j >= 0; j--)
    2 c( i. N  r( o- r                {
    0 h0 D4 }1 N; T0 m2 I8 [                        /* floating date operation */
    # p- d/ D6 L% e  W1 Q2 J                }
    8 e4 |, ?9 C! \/ y& v; Y; [; K3 C, G
            }
    $ z/ n( x1 ^( \# p}4 q# o9 A+ r; `- |5 e$ `" Q2 S

    + v; x6 ?9 R8 _8 i. }xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样  X" s, }8 f# B/ F3 W+ y
    # h, G! B# j( G! R3 X) s
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。/ r9 l! [) j8 X3 z+ ~
    现在call xcorr 100次,耗时78s.* x8 E$ O/ P8 W
    5 h6 w5 ^2 H: x8 ]+ b% k
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    * L: ^5 ^6 Q3 L( e
    7 v( R. W/ c+ ?1 h2 q" |) N
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33  i: J! x- K0 V, `! `+ I* P" g- z
    Maybe Debug mode?
      H2 c' Z7 `7 `6 N. D+ X; k( U
    ; V% ]( p2 q  F! X, ]) c! f$ @6 m
    不应该,看我上面的回复。+ k8 e; _( a9 P
    . G( l. P; U5 ^' M; H2 u( D; |
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    前天 22:23
  • 签到天数: 1950 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 ! H0 P; Y" b: O
    雷达 发表于 2022-9-24 23:54
    ) T1 g% D  @2 u6 G/ m: Nvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    - v7 ]+ B) B0 t{
    7 H% Z8 F6 b( |8 \6 L: O        comp temp, xtimesy;
    7 ?6 W& j7 {7 {! g, h  C% J
    6 w$ K. w* X" u+ W& i( d
    这个不是这么比的吧。。。
    6 `" [* l9 O0 N* U$ `) G. e3 N. `/ n5 I
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。5 u: J: b* b1 ^: j' T, _; s6 U

    8 _6 h7 Q. D/ p) ]2 @而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    ' [3 ^5 N% u( y' l
    数值分析 发表于 2022-9-25 00:20
    / \5 a, E: N" N" ~9 V- s这个不是这么比的吧。。。( e2 ?; J- r5 V/ Q5 C7 Q

    / s8 @* ^* `) k% m$ i' H7 T2 }* X您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    . V9 |; l$ J, x' U  U6 u( Z; V( m3 ^" d2 `# x: a" f, K3 j* w9 @
    有道理。
    : N9 c2 H0 ]6 a. p: l( a; ]: I所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    / T& v& P, v1 W* M( V- m) E( w. @# R4 P) f" C. x
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46: D3 h- j- F1 h6 Q. g8 v6 c& l
    有道理。
    ) m9 {1 @1 y) d. M3 b! Y2 h所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    + B: N6 C/ l, A5 b1 P1 \9 r7 v你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多# H; ?1 d3 |5 o$ Z
    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' Y1 V0 Y' {3 ~  |. n; E$ F
    这个不是这么比的吧。。。& s' T5 j! r0 A7 w- P1 C. E

    " F+ C! W4 n; t; w4 M9 s: z您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    1 }. U! l' u5 E$ R7 g) ^2 A; i

    ( u9 }. ?+ n2 A9 B7 d9 b" d现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    前天 22:23
  • 签到天数: 1950 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 & f9 a! m2 S  L- `- h6 A
    沉宝 发表于 2022-9-25 01:48
      r! E2 [# E7 f: o; Q8 ^+ `现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    3 U/ O3 ^) B9 D$ N  S

    + C& B$ F" k3 T: ?7 q9 _% j* b" C是的,兄台说的对。5 v7 N4 j3 a4 u+ S/ k8 \$ _! o

    8 I4 ?2 K2 Z; m9 }4 D. w( R$ M. p3 T其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    ( L: l8 P5 v+ @. ^  r) Y9 B
    3 x# `8 V& `6 T8 W雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。0 m9 w2 n3 S: |/ i. ]; c
    - x, w: g! H( n9 O, B3 l$ l. A2 _* h
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。: w& V3 x3 R2 e, a
    5 p/ @: \. z! z( \- @+ y
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    0 x5 \7 U4 T( a) K0 E
    沉宝 发表于 2022-9-25 01:27
    - y$ r7 y" }+ d4 f' Y  f. ~你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    ; N3 w- k9 m) e  v# u* w9 s3 b; _

    ; k4 s+ ], }3 w: q又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    ' ?, B2 K5 s8 e# q) [# A1 ?! x% J
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    7 o- T6 [/ K0 i4 _( e0 s8 }又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ) K2 J2 w9 D/ y6 y时间差一倍的结果可以接受。8 d8 q2 r3 {0 F: \/ _- O0 ?2 q" H

    ' {+ W1 a+ _* z2 L# v  P你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    前天 22:23
  • 签到天数: 1950 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 + a4 u% g2 L% D1 J2 r4 \6 X! C' \
    雷达 发表于 2022-9-25 04:47
    " f: q2 F% f& K: e9 |" ]又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    8 h" J- k4 T8 k

    ' w6 N- i9 w; B7 t4 Z+ K8 M7 y' Q
    9 ^3 V4 @+ C" D' L# ~/ N3 ^- }, ^3 f2 j! V9 M
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 - l. K6 {+ s9 F8 U4 Q5 O8 J2 R# ?/ q
    数值分析 发表于 2022-9-25 14:58
    & t+ B% t, W- u5 l, A; W3 s6 W能不能把这个也贴上来,看看和上一个有什么不同?

    + y/ r' W7 Q( }理了理思路,重新做了一个测试。
    7 Y7 y$ A  J8 `- l$ r9 L$ Z6 I  e做了两个 vector 和 两个 float *, 都长 100000
    - e- _4 C9 B, u  z# w2 g5 D: l外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.  m8 P2 A* U( R" @! p+ u

    . N0 _' ^; y2 P' b0 W! K内循环试了4种方法,9 D  v4 @2 @; L# V, _: i
    1. 直接调用 vector inner_product 247s
    5 z) W0 U6 t& i9 `0 |1 w. O2. vector 循环点乘累加 237s" ^# k* t, b6 t& k  P! v" m
    3. float * 循环点乘累加 204s
    # ^) P$ P! i  v* \4. 空循环 100000 次 202s
    ( t$ z% m4 |' |/ w! m: ?" V! r" L# \9 c& f: E9 G+ Q8 a
    不做内循环 200s6 [0 c) L8 W; |9 N- V2 l

    $ q4 x% R: |& ~) d/ W你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    - n2 A7 V8 k* m" E另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    % S1 E3 \6 a. Z) n& ~0 f( K6 |. ?
    + ^" Y' d, M: T; \8 g: J; \至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)  `7 S: p+ b+ \1 ]2 i. m
    ! [! R0 Q2 L7 @  `* f
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)& a# \( k2 |! A: D' W" ]

    / f" v3 p" _# K: T' W5 v4 ^; `
            std::vector < float > vec1(N);) p1 x- d$ D* e, M+ L( p
            std::vector < float > vec2(N);3 z: a  T- t/ c- Q4 s$ Q: r
            float* b1 = new float[N];
      @  H- a: E" l        float* b2 = new float[N];
    # V4 t. Q* F  V# i
    ; N! K5 F! X1 P; X, e- T        for (int j = 0; j < 6000; j++)
    ) _/ A2 m0 J: J" M3 W: A        {  r1 {. S0 U: R6 o( k  P
                    std::generate(vec1.begin(), vec1.end(), []() {. Q' E0 N: w  y4 @" f, p) Z
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    - @% }! f' v0 ]                        });
    * Y/ e, b) ]; z- ?* G. \1 J$ i
    9 p' x4 x7 W8 z' B. L                std::generate(vec2.begin(), vec2.end(), []() {* m7 j: G. D% }! D
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;5 U" Q& j6 X! l
                            });  S  Z- r: v! }% s  T- d

    7 r- y4 S2 m* T5 |! ?. v- E                for (size_t jj = 0; jj < vec1.size(); jj++)& {. l9 y' G+ A' e/ a
                    {' X1 R5 ^& d/ u3 @2 v
                            b1[jj] = vec1[jj];7 E# u/ V1 \2 G8 y0 C3 Z2 w
                    }
    ; m1 d4 M) v" X2 _' b; G6 O1 ?3 H0 ^+ P
                    for (size_t jj = 0; jj < vec2.size(); jj++)
    " r5 U5 s- Z! K4 Q& M                {  \4 _* P+ [5 f+ C4 S& {% Z
                            b2[jj] = vec2[jj];
    4 l) j  L1 o0 I  a                }, {8 W" `; Y% \' j. ^" d
    7 g% z( \, D( s- E) o, o( w* K3 f0 B1 U
                    //Method - 1  N=100000 247s  - [; K! }6 ?# n( _& N* B
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
      [4 _* n" P  O                                
    ' C; B8 R9 I1 T1 x* f! S: o$ x                //Method - 2  N=100000  237s2 f6 T- B6 H+ T+ h. l$ B& N8 g- w% B. o
                    /*6 y0 s0 g  p. b, r: x
                    for (int jj = 0; jj < N ; jj++)
    4 g8 ?) K4 D5 O                {
    & n& J4 U0 U# ^, m7 b9 G                        fresult += vec1[jj] * vec2[jj];8 t9 h( u; v; ~
                    }' b+ R# m. K7 e# G" ?* ~+ R" t  K
                    */
    , d" ?) B" S) f                                ( ^# [$ n$ u6 X9 q' p
                    //Method - 3  N=100000 204s3 o" n. \6 g# [% P: G. x
                    /*3 t! ~) M3 ?+ _6 q7 d
                    for (int jj = 0; jj < N; jj++)
    6 k5 P% S& S% q# K  [) g                {
    ; x  i/ _* i0 `9 z" P" y2 _                        fresult += b1[jj] * b2[jj];( d7 g, `' Q* `2 n6 o! ^" p
                    }- D& \2 G, A$ N0 b
                    */; [6 L: {0 Q# ?7 B' S- N; u

    ! V! B: H+ [+ l                //Method - 4   202s2 m1 M  C) \7 T
                    /*
    & Q$ d8 W/ t9 U) r" r                for (int jj = 0; jj < N; jj++)
    9 H# P# B$ q$ Y' ~& q. d                {, |# b  ~! K9 i  D! T4 A$ d  A
                            1 q1 o6 \' z& }& M$ {( u! {0 I/ z; X* A/ g
                    }
    - x: q# v! K8 A8 B                */8 t$ a' i# P# b6 Z) n7 m) {
                    //comment out all methods, N=100000  202s               
    5 k: z. a9 ]& n" o5 C" @        }
    - O5 _2 g- y9 U6 v3 h; E1 I3 F3 g
            delete []b1;
    " R) h  R3 x1 n: l6 E) p' u& V        delete []b2;
      x; u7 [4 ]) F. x
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?4 O( J1 M* h* s& n& l& {
    $ a' A# E* }% {+ _2 o; W: p/ B
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?/ u1 k4 o0 t( [
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    7 V' i$ x& [" _9 D: L2 `1 j瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    & @6 S7 T4 M* j
    & b: G- [3 f( G/ I/ P: g+ c: x1 D$ ?: y, a你第二个试验里面的j在循环里面又重新定义 ...

    9 u) S- M& b/ i5 c  r/ @3 p内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL) M* [  c  T1 b3 x( X# G
    6 b, P: ]: h4 B% n7 E* Y- e/ ~8 P
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    : R: N2 g' S- W" Y7 u, K, e内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    $ y& e' x! E- B$ B
    1 A/ m+ u. f- y$ `* b不和它 ...
    ; i- B) Y& G) v% _$ b3 O
    ) v* ]( n- A+ e; O: F' h# R, [, i
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。% |, Z" e) Y, L% r7 {3 R& k7 A
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    % a! n1 x9 [' l" v$ \) Y- [  mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    1 K4 b9 o& w# e{
    0 R6 P9 V& r6 y6 |6 }! H        comp temp, xtimesy;

    7 P" V$ m  m9 a7 |( m! e6 c这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。, P8 B) `/ ]$ P6 N. \
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?8 [5 x) A( M) T5 z$ F8 t  q
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-10-24 05:44 , Processed in 0.040404 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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