设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?) R" N! L% o1 g* d

    6 Z  C7 z+ s5 K5 U( |5 r自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    & x0 _3 U3 W8 O) J+ g/ F7 F1 P6 p; c4 o9 U! f
    速度优化问题真的很有意思啊。
    0 J! B. j$ V+ B* q6 \8 }9 t; Z! [
    8 Y" h  y9 B; w" K; \) H1 u% f* U欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?5 [; T" M$ e# }8 K9 ^* K
    把代码贴上来看看?
    . v  l1 R( m- ~
    ( ]3 }4 F0 ]5 y- d$ @5 ^难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 ; K- ?8 C/ x  ?& h  j( A7 p
    数值分析 发表于 2022-9-24 23:04" y- d- n2 S' v
    拉下来?拉多少?
    $ W6 }5 c" }! J4 N1 W5 Q把代码贴上来看看?

    % z3 o# n5 L- c! a+ v& S( _; W7 [+ A' v+ b6 K5 K
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ) a2 d6 N( l4 M2 ^) |{
    7 T1 l# G) g" N% {        comp temp, xtimesy;; t, Q; m+ I$ ^2 `( k" }
            xtimesy.re = 0;
    $ {9 h* }' t' m  X; V# c" Z        xtimesy.im = 0;: o' d8 Y. E& ^7 Y, F3 I
            int j0 = lenB - 1;
    / j* U. ~. z2 f& t: z5 S6 }/ }        int    i, j, i1, reali;
      A  U  c7 K2 C7 I5 r" X; ^        if (lenA % 2 == 1)
    0 B: q  ?8 `) \% F+ i+ Q# X                reali = lenA + 1;3 l; `# ?2 o* h( S
            else
    - z) N& o! |1 m2 S" I                reali = lenA;+ I- Q, X+ j  x1 F& r' {6 W" {/ |" @$ i
            reali /= 2;7 b$ r6 A% c" @
    $ O/ a& n& b5 r" v! {
            int nconv = reali + lenB;
    % C6 C$ s! I7 G. `        //#pragma omp parallel for
    # F% i- Y) r; `+ d        for (i = reali; i < nconv; i++); o( h* ^9 g, s8 y3 e4 z' {
            {3 H1 S& M' @% i" y& X
                    temp.re = 0;: z1 F7 }4 a+ j6 @/ ^
                    temp.im = 0;/ [2 _, o9 q9 f8 K8 G1 I
                    i1 = i;' J1 C4 F$ z5 B  B# _$ }  `
                    for (j = j0; j >= 0; j--)% @4 N1 Y0 ]* u5 I- l
                    {
    / ]3 m3 K+ {3 G9 e, \6 ~- S' a                        /* floating date operation */
    6 o2 I/ e$ x: |                }
    0 N' T3 u0 p  M
            }
    , |: n  D" q- h}* R* B: Q/ N! m6 u2 Q- R2 K( n
    ' ~' w6 N3 n7 ^+ y" ~9 \
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    - ~: d1 p9 }( y) D: j5 P1 T* R) B0 H" n# d6 \$ Y
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。1 v: O! G% P2 r7 s3 K
    现在call xcorr 100次,耗时78s." Y  |, ~. p+ P0 l

    8 a( L5 z8 n+ e7 n$ |3 Y如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 6 y3 z. W% I$ Y5 b! u
    - b* v2 t5 g9 z/ r# B" H+ }& F
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:332 L6 F( I: \% D" o
    Maybe Debug mode?
    : s1 T$ J3 o2 L: Q4 }

    : @0 |7 [. U/ y# e5 S2 x不应该,看我上面的回复。
    1 w  O+ ^+ ^/ f4 k( h: J# s2 V9 K% Q: _8 Z6 C1 f  q" V
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    ! ]) ^0 ~8 @( J  w! `
    雷达 发表于 2022-9-24 23:544 [! |' I- _- ?- G
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)9 m; [2 x8 b8 Y
    {+ i' |; |/ W: x
            comp temp, xtimesy;

    3 c; Q( r8 s8 M3 H. ?0 x% g7 l0 y  K# y8 [' ]& ^/ J1 R2 u
    这个不是这么比的吧。。。! S3 J& F5 a( y4 I

    . ~% z; f- P5 X- r/ ]% ]# ]: d* m您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。% E' m1 g( ^: U: q% w

    % x" {) w1 N* [而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    3 n4 X5 `* z2 O; u/ N8 q8 S% A
    数值分析 发表于 2022-9-25 00:20
    ; J2 I5 K( I" s这个不是这么比的吧。。。) ^" A- x7 m% e* k& U
    ) O" E2 ~  u9 H% C9 `
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    9 |8 Y  ^6 v$ ?" V1 C% W3 G3 B+ x3 ?) T8 i
    有道理。
    0 B1 \' o! m# d# Y' B. }所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。  Q  V2 R/ T  W! w) R

    # f" D1 ]0 K  w1 x& {我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    , s& y; {6 @- Z; j; ^* m1 M. U有道理。' C" O5 Y, [+ T6 w4 f3 r
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    3 V/ y3 E% {6 E
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    $ Q/ g8 G$ G& O2 PWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    ' @3 p' a8 d0 v, [  s这个不是这么比的吧。。。# R: Y4 V8 W  `4 n! Q( E( O
    " N. d( d3 r2 W( R. K
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    6 S! m1 L' W2 p4 r& `: i& v, n0 ~; ^! O& i( |8 m! R
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    6 G5 U9 C( e) r' u  z$ b+ ~; V' M, a
    沉宝 发表于 2022-9-25 01:485 x$ y: F- @) ~0 h$ u; A
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    * l0 ^% [6 R, P- x; j. \$ X7 a
    ) t; G2 l4 h6 S( G' L
    是的,兄台说的对。/ s1 A; g/ a8 w1 w& s* C6 J. _5 Q

    1 y0 x; a( w$ }& }- l其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    * b: F) V4 s# R  d0 Y0 J, H, T+ J
    ) f% L- e7 G5 P1 v, H2 d雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。" ?0 s, \6 D! v( s- Y, W
      U) l- n. h) \6 i, I  I
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。/ W: L# \$ n$ O+ n) j; B$ T- f( A
    7 z$ b& G. V: u+ J! l; f$ p
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 : J" B7 t9 G$ n2 e2 F4 J
    沉宝 发表于 2022-9-25 01:27
    ! q3 v3 T4 r* H+ @$ S+ d6 n你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    ' D& J* E) S+ y; O- W

    $ I! Z1 M0 Q- w3 d又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    6 c0 q5 L. U  U. c( O) A% t) I6 M7 Q0 ]! [# U
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    $ ~- H) }4 |9 y: e! ]" K, _又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    & T( v1 S, ~+ P( G% Q; x  q# i1 T时间差一倍的结果可以接受。% c2 O: P# F5 N5 }& U
    ' U) O/ n4 z. r9 E: t# y
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 3 k. t4 V4 T6 U% u' E
    雷达 发表于 2022-9-25 04:47
    8 K& Q3 B# a! u- o4 ^3 z又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ( t* V8 Z, h" z2 a5 }: u- Q! K! N1 b% q0 y. {* _

    9 E1 H; d8 O% ^! x
    1 Z& X$ k* I5 ~& r, Y( w0 O能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 $ Q" K9 g9 U6 U
    数值分析 发表于 2022-9-25 14:587 e6 A1 y% T$ k8 Y# Y: {. m8 {. B
    能不能把这个也贴上来,看看和上一个有什么不同?
    ' L5 `4 c5 l! G, [
    理了理思路,重新做了一个测试。5 f! d& ~& |2 F' `% L$ y( O
    做了两个 vector 和 两个 float *, 都长 100000
    ! a: g& u2 N' \外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.- I$ S6 x% J- ?  q8 g$ r' q$ B1 o

    4 L2 S5 ^$ i5 y9 H" n/ d1 m  H内循环试了4种方法,6 t. k" T- O( r# w
    1. 直接调用 vector inner_product 247s
    ; I2 I! x" |9 I* r' Z3 q; Y/ R2. vector 循环点乘累加 237s$ K9 n% O& T$ C6 U
    3. float * 循环点乘累加 204s( K% [" i- u2 e& }" c5 r
    4. 空循环 100000 次 202s$ J$ b$ v6 A1 R+ \

    3 L, u" r( g! d+ E/ f- j# ?1 l不做内循环 200s+ N6 [7 S. ^  p) ~- U7 |
    + E' W$ o; k) J3 c1 G) l
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    & _' Q* e# n, k: r& ^另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。, _0 V; ~! j. i+ ]) T  y9 d& x4 w% V& Z
    4 @, i, e4 |* R9 A/ ~
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    + x  g0 I& v0 t1 o7 T. K& b+ x* A+ E- x
    % f) h5 K' `# ~# d(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)# }, K- b8 g/ p% g  r! A; w+ w
    ! j0 r) J  l, B- P( p
            std::vector < float > vec1(N);3 P- C3 q- b) ^$ K' V. f
            std::vector < float > vec2(N);
    3 u. P5 e3 M2 O- i& G" ^& P+ _' A: _        float* b1 = new float[N];& b1 h2 T5 j& Q; t8 M/ o
            float* b2 = new float[N];, p. Z( U5 ]7 U% L5 K' O
    ; |- d; n, Q7 C0 s2 Y" b
            for (int j = 0; j < 6000; j++)
    * q' U; w6 S# x1 _8 b        {
    ) m0 C/ s( m% n0 P                std::generate(vec1.begin(), vec1.end(), []() {
    3 {. t' W) Y8 i8 Z3 F                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;) A4 n1 v' R3 q& C( c- Q; a
                            });9 Q: E( ~4 C5 o  ~2 i6 V& m
    2 b. B+ V9 s' x2 A7 l4 g) y- Z
                    std::generate(vec2.begin(), vec2.end(), []() {1 J( U+ ?1 R7 m& B2 J: Q
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;  [4 H$ B& }7 w5 E$ r/ y& R, ^
                            });
    & A: d) l1 m  Z  T  F" `  [3 J
    2 Z# R, W  T% U2 g3 M                for (size_t jj = 0; jj < vec1.size(); jj++)
    5 b4 R$ [6 X/ G! _- ^                {
    4 W( Q" M0 Q$ X4 i+ s, }) F( l- \# I; N                        b1[jj] = vec1[jj];
    ( P. I# @7 h1 V: W0 h, Q: T0 H4 T, S                }
      j* g3 S: \$ r" ^. S2 ^
    + q7 c! \' A1 }: A                for (size_t jj = 0; jj < vec2.size(); jj++)  B! m' a+ _; b; q
                    {
    : L& l& n) i& J                        b2[jj] = vec2[jj];
    ) K7 ~9 S$ V. u8 U$ W( i$ h! m, }/ |                }
    $ i% R- o9 ]2 P5 M5 i' s* ^
    : k: r: b! @6 k                //Method - 1  N=100000 247s  & y! I6 A# }% K& O0 t2 O
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);& W% f* g. @3 t0 H1 ?: w( K9 X
                                    9 k; \8 P0 I7 l, e4 Y
                    //Method - 2  N=100000  237s
    + }& t: d4 H% I0 Z+ P/ ]" n5 r* q                /*- e$ M- z' L  K
                    for (int jj = 0; jj < N ; jj++)2 k3 f2 Z8 n' x( b" I, g
                    {
    9 p! F; V- X1 E: T                        fresult += vec1[jj] * vec2[jj];# h9 N$ _; G/ `8 R
                    }
    ' l- c  H2 @: }1 h; d* }) l                */
    ; D1 {, {, o0 ~* h4 D# A# K                                2 _2 L& j* J: @1 w4 X3 E
                    //Method - 3  N=100000 204s
    0 M0 s, a5 s+ p- }3 ~" B                /*
    3 \+ E' ]1 O# z. T/ U& ^                for (int jj = 0; jj < N; jj++)3 W* y& Q% _! u' k5 ^6 i; {  D
                    {& K( S% x6 S& \5 ~. A7 O9 K" R+ g- ]: O9 k
                            fresult += b1[jj] * b2[jj];
    7 P4 S& J# o7 v: |5 F                }
    6 c5 }% X' Z2 t4 k2 F9 n                */- L, ~- T- |( O5 [

    + V8 U& t; u0 B  S* q: d4 P# ^                //Method - 4   202s4 C% M' L% H; y6 ?$ ]& ~' \, B  |) \
                    /*% [9 ?- b* `' o" f9 i
                    for (int jj = 0; jj < N; jj++)' x- g$ Q& \3 @. F$ }9 Q
                    {
    9 ?1 K* N: u- Q2 V* L1 j                        4 F+ l, M9 b' ?/ E8 j  Z
                    }/ s$ k4 E; {( L3 A
                    */
    " A6 m$ k. b- L+ X                //comment out all methods, N=100000  202s                $ l) g9 h/ V3 Q  o  t4 a
            }5 q+ f8 i# J& L
    ) ~' U( o% p1 ]( J# r8 o* \
            delete []b1;
    2 Z. j$ o7 m, b5 g+ c" F+ O* S$ S        delete []b2;

    5 ~/ d$ S+ M, M& N7 V- ?
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?9 ~  M/ L6 O/ U' G; r6 R: N
    # H: O+ g+ v; l1 t# v1 l6 F
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    . h* W5 L0 P; N! s8 P
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    1 u. y; u/ {6 D) ]! p瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?- R* O0 U# j$ F7 `& O
    1 {+ n$ }3 F3 [9 S6 |
    你第二个试验里面的j在循环里面又重新定义 ...

      l7 J1 m* J( B' V* {* E/ D0 f- j内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL/ c+ K/ G5 d7 p) [. ^
    % X. E6 g6 Q/ \. c
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:165 G  P6 V1 Q7 C+ u# i/ ~
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    - P- k: [- W1 I0 c
    9 o4 b% P3 N+ c不和它 ...

    $ V9 B4 ?: |: a4 [* v
    6 @# o7 s8 Z; k2 F7 d不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    & G1 R. i1 O) L% f6 ~& M% G后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    , p8 o! f8 b8 g; Rvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)( u/ w$ K& P) g9 @0 L7 V/ f6 v
    {
    % [( V" x3 ?3 Z        comp temp, xtimesy;

    , ]" L, X: l5 D, p6 r这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。; U; A& F8 p3 y- n3 _: A
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?" Y( x; K$ u1 I4 H4 f# W9 }8 |
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-2-19 06:14 , Processed in 0.049734 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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