设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?
    + X9 ]8 ^# \4 z( O5 l/ r# n* p& F# K! E
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。. ?( G5 L/ i. a

    - ^2 b% @  K3 N, n+ n速度优化问题真的很有意思啊。6 \) x# e% i. Q1 `$ t5 Z7 e5 [

    3 H8 ?3 R2 X1 q3 z欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    ) d- i# X! c) W5 k" ~( u把代码贴上来看看?
    ; B9 {  Z/ I0 G, u/ W9 ^) n5 i
    % S1 c! d1 Z6 Z- j难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    1 `& w' I$ k4 x2 b* d/ L
    数值分析 发表于 2022-9-24 23:04; ^4 b& p- E0 @- x. F8 j
    拉下来?拉多少?- ]7 \. M* R. w3 H3 ^6 i
    把代码贴上来看看?
    : s; d; C9 D+ a/ |) L" O

    9 r% V7 N( {; ?, e0 I  t: ivoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)4 J) k1 P* ^  @1 t* g
    {4 w. |' m: v* \3 o
            comp temp, xtimesy;
    * g% N6 `8 @$ A- s/ @# y' M' ^* J        xtimesy.re = 0;
    5 I7 h9 Q# k# C) ~) u5 h        xtimesy.im = 0;
    ' ?. Y0 p: W- x9 r7 A        int j0 = lenB - 1;) ?1 `* {$ g" c7 L& b2 o
            int    i, j, i1, reali;
    * L9 S1 q; u/ r/ N        if (lenA % 2 == 1)( Z2 ]; r: ?# z* r0 T' M6 r
                    reali = lenA + 1;. V+ I/ n" ~4 l  W
            else$ }- G" v/ L6 Y, T3 a
                    reali = lenA;
    1 G, [0 l5 u6 c( |        reali /= 2;% f* [* O) {! @
    6 C' Z1 d/ f& ^, j2 p/ G5 V
            int nconv = reali + lenB;
    ) B. Q* f0 T/ e/ A  g        //#pragma omp parallel for
    , z' [( r2 N+ l! u        for (i = reali; i < nconv; i++)
    $ z9 t7 y! G( v- @7 p        {
    1 R+ S( J7 G3 O. J/ V                temp.re = 0;
    ; a6 d/ n! ~' j* R7 i/ T3 M' K                temp.im = 0;
    9 d: T1 [" s6 a' U1 z& v5 M                i1 = i;( {$ B/ w$ O; K) e  a1 E% a
                    for (j = j0; j >= 0; j--)
    + U* `6 X( s6 k7 y/ f                {; Z+ t0 F$ N6 v* f* ?
                            /* floating date operation */2 f7 R% r  G4 ^
                    }

    9 u, S5 L. L" `3 b9 ?! ~$ m7 Y        }6 A$ M2 K- j+ A  }. c# J
    }
    4 {/ u/ e4 n$ N% O
    , H  W2 ?0 I4 k7 _+ N' o% Cxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样. h0 N/ q0 G4 F$ \$ R

      i( X! J2 W# C; Q红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。9 k5 V( h/ b0 X5 w4 {! r
    现在call xcorr 100次,耗时78s.
    - M; Q! G( A2 P2 D7 T
    , h& H/ B3 @# L/ S7 X如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. % ?  x4 r8 ~7 W# {$ [$ K6 f

    ' D% ]) s1 x* L: X% C4 v- L2 f9 Y; Z
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:336 D% _6 k. ?: C. _4 J, q! Z
    Maybe Debug mode?

    * E5 G! J$ }+ ]: r) T6 j+ g) S3 G4 a6 V! I2 D/ N  [5 Q
    不应该,看我上面的回复。
    0 j% ~$ [2 @3 w4 f- ?2 Q! c! A% u0 x. u, E
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    8 P' U: K  w8 \' w2 H. z/ f9 q
    雷达 发表于 2022-9-24 23:541 U2 Z3 B1 i0 T$ X! h: @/ {
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)6 {5 S. T, m0 `
    {$ Q; ~3 t7 \+ L0 u% _
            comp temp, xtimesy;

    : B' v7 U- x) v+ s" J+ @9 n3 [1 t% I! K6 ?" Z! R2 K
    这个不是这么比的吧。。。' {: c  P- b* m, U; }: ~
    : f5 S* v4 t2 D& y5 l+ Z
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。2 \/ M5 r$ u: z0 U& A7 n! E

    & R! D, H0 i" ]5 v而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 ' D, [* q) g& O3 K
    数值分析 发表于 2022-9-25 00:20
    ( g, L; r% i$ M& q这个不是这么比的吧。。。
    $ K4 e, o3 d2 A2 T' D( v$ ~4 G; R+ Y& ]1 a
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    ' U7 x( Z8 G0 {; m2 ^: s& a  q2 F, }
    $ f: i4 A! J4 i/ X5 Z/ \
    有道理。9 H2 ~0 U* x' j) w& s) T
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。) J9 e  T( P- B/ I, r

    & y) [( B/ {) w- ^8 P我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:461 p5 h$ O, p) z, ~1 d& k& U
    有道理。
    , V( {) h, }  A3 _: Q) ~6 C所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    + v, _, m) D0 W9 }你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多0 D% r/ P* c8 o7 |) T( f* _1 e
    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% p0 y$ O+ U- w0 k
    这个不是这么比的吧。。。
    $ l6 y5 |4 I0 w/ ^$ Q2 d- ?% X$ U5 k" o) q# ]
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    * E5 X* i! f: t

    6 `+ k  u7 Z0 U' c现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 " J( e; m" c  Z; t7 t0 E$ S
    沉宝 发表于 2022-9-25 01:48
    ( C1 J. e. \- U4 @% b$ M6 s现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    ( k- I- b7 S* G0 n) ?* P* A. a
    + R/ g$ a* X) H6 t是的,兄台说的对。  n* o: Z8 Y+ w1 _7 k% K2 g

    % B) f' x, \% m7 a2 e" g其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    * T; E) q! d  N0 H( f& o8 p6 v3 A% Z5 d8 r2 a( ~
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    2 V9 i9 R2 _% ^  E  z# F3 r: G' q
    3 D5 _8 x; M4 O' }* Q$ n- s6 \8 l比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ) b$ s2 i/ n) B7 f$ w  R' L) _
    0 J0 {1 H4 K5 @- X4 ^( H' L当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑 % y5 i7 {5 q/ C# e# ~5 `
    沉宝 发表于 2022-9-25 01:27
    " s. Z" N, w  W3 i& V- A1 N你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    * {$ t/ h; n$ n9 j" K& I0 N& }9 D' D' B$ x# Q$ S# p
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。6 q$ i2 i% U& D* ^( ]
    " N& W- G% B7 \8 l. w9 G, t: v$ U
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:475 E, `6 i% O: q# i% a* D
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    & G6 M( U2 y% Y' l0 f! g- r+ R2 U
    时间差一倍的结果可以接受。
    $ A% _9 P* \! E
    7 M9 V5 _- m0 M你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 " _2 p0 N: ^5 a0 B6 T
    雷达 发表于 2022-9-25 04:47
    9 O1 j  K+ L8 Z7 Q- M) r4 I又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    & Z2 Y! N/ I  ~0 Z% \, S7 v
    * R7 |( o; Z7 f4 I: X; u& N$ ]# w2 B( c6 x' h/ N, X/ z: M

    - I% ~1 L! g( v5 V1 T2 u$ h+ V1 l$ y5 t) I能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 4 p( W, p' }* E& `, A: O
    数值分析 发表于 2022-9-25 14:58) Z) x7 ?. c& F8 e
    能不能把这个也贴上来,看看和上一个有什么不同?
    2 A7 `8 B; \8 s( m
    理了理思路,重新做了一个测试。
    1 y) Z+ b+ I( E' c7 o, I做了两个 vector 和 两个 float *, 都长 100000) v0 t( G! k" w( O: x" H
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.9 }- o' W5 s5 G8 X( u. t3 Y6 f

    4 j7 w( \4 j) j9 f内循环试了4种方法,
    0 s2 o/ x0 t' X' ^8 W" O1. 直接调用 vector inner_product 247s
    - R( i6 w0 t0 M+ U2. vector 循环点乘累加 237s
    ! e( r9 x" H/ _; H7 q) h3. float * 循环点乘累加 204s" O' z6 B6 [/ {# a! e0 R/ C, D
    4. 空循环 100000 次 202s) X) f- K3 Z2 s- M1 I' G# l" C  N/ i

    6 `2 E$ u( T3 x/ |. f7 F0 p不做内循环 200s
    ; B2 P, d! v. C6 Z9 N# T) _% F* v. s7 ]% e
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。& _/ j& |' G% K, A- _
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    1 u# x8 _' g1 e0 g  F' M- t4 o& `9 ?3 Y4 O& Q7 c
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试); U7 i" E2 C. |: s4 T2 j% Z- C' q
    7 x+ Q+ q5 x. U. s, q8 y
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
      V& F% S' G5 W. H" T& z! }; F) N" z
            std::vector < float > vec1(N);+ ~% ?1 A! ]( u
            std::vector < float > vec2(N);! \' t- ]# x  X1 S3 I
            float* b1 = new float[N];$ d# g% z5 q; g' P$ f3 K5 k0 x/ T
            float* b2 = new float[N];
    9 m6 }% K% F" ^7 C/ }2 t  N; t
    ) H; C8 f) X- ?& `2 A4 g; X, U        for (int j = 0; j < 6000; j++)# q! y7 o5 ~4 e9 p$ i# P1 P- d0 x7 F
            {+ Z. Y& C- r$ N/ w# T% k  w) f) `
                    std::generate(vec1.begin(), vec1.end(), []() {  N9 ^. o* a* Q( L! b- L
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;# w# p2 ?" N) ^& Y
                            });) U# n( z5 R! Y& k& P

      i1 W7 I9 p& _) L9 a4 U                std::generate(vec2.begin(), vec2.end(), []() {
    ! N  s  }7 C4 C5 }( L0 g. F0 W% @                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;8 E* u: ]& B' v( a, N) ?! v  \$ B2 s# c
                            });
    2 x" }2 E% X1 d
    ; j) J) Z( C! A0 }  R9 z                for (size_t jj = 0; jj < vec1.size(); jj++)5 Z$ j: V, m) T& o4 |' \  Z% F* S! }
                    {
    . L; @7 g- R% S+ F8 x8 n' {                        b1[jj] = vec1[jj];" h  J6 _( l3 g9 B: L
                    }! l4 p) [7 t8 |' U: N) e3 Y
    " Y% M5 F: t* v) E+ |
                    for (size_t jj = 0; jj < vec2.size(); jj++)
    : s. l9 I  Y8 M4 V  v                {
    2 W2 |+ a, n6 x% F  t0 p, [                        b2[jj] = vec2[jj];& E+ B; T6 P  n0 W6 X
                    }# H0 q. [" i5 V: q! s

    + g0 l6 S8 W' C$ G5 q                //Method - 1  N=100000 247s  
    7 T; |3 ?- f; l) q                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    : B' m; i4 ?( R8 W6 _                                4 w, O: t) u1 [5 B: |
                    //Method - 2  N=100000  237s7 D5 U0 @% p/ M% G  m# P6 H/ ^
                    /*  t, [5 S5 h! f# F; F7 c3 r
                    for (int jj = 0; jj < N ; jj++)
    . r- }: ^1 m( {                {' R4 G9 U5 e* ^9 P+ y" e- p; |
                            fresult += vec1[jj] * vec2[jj];
    4 q9 s* f, ~) Q+ r% D. b                }
    0 G+ n6 y. y. M. N# _6 y                */* s0 k% f6 B: O5 ?  R
                                    
    , x" P2 J7 l+ B; S                //Method - 3  N=100000 204s9 r, G/ H0 C7 Y$ e& l# S1 d! a$ W
                    /*% r3 v  |) e# V& c) C+ G( Z
                    for (int jj = 0; jj < N; jj++), h9 L7 k" N+ D
                    {; j  z3 u) |+ A  T0 v3 n. ~
                            fresult += b1[jj] * b2[jj];" }: `+ r; |8 @, r  i
                    }" ?8 |, k( w: k0 H8 u7 a2 a
                    */6 t( d& W, x/ i! Y

    ' c" N" @9 p7 `! z7 \9 Y# t! ^                //Method - 4   202s) L# z% Z: l- x. U! b# @/ t
                    /*
    . D& i* M6 V1 x! D3 r6 B& D: c                for (int jj = 0; jj < N; jj++)
    , T8 F- D& a/ w                {. r2 f3 u. r; S* g4 y1 e& G9 y5 G
                            # A' M- v7 s/ m4 s( \
                    }
    5 |9 z0 e6 I. i- V                */8 N, s7 g! G% [& S% C8 S' e6 m
                    //comment out all methods, N=100000  202s               
    & l; _  S; H6 V! B3 x) V5 B3 H        }
    # R9 e  `0 `) W: H# A6 H$ Z- w- B9 F% l, ?: C6 g1 m; U
            delete []b1;2 o6 {% b- s' v7 \$ F# a
            delete []b2;
    6 W) `' j+ G3 B
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    4 S# f6 I/ I. R. W' }9 w& @- A. ~. ^  G/ s
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    & c. R. y0 i& |. e& x1 ?5 D* g5 `4 I
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    + X5 N  U; g6 V9 J, [$ G/ U" \0 u: G瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    : n7 J) @( o2 W) D, c1 G
    - J6 Q- i0 ]$ l% K6 E- M" w4 {你第二个试验里面的j在循环里面又重新定义 ...
    2 s3 K( h$ L$ T) z4 y$ F# m- h1 j
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    : ^+ r8 ]: y, U8 Y: z0 o6 y( x/ r1 M+ s( B
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ) ]+ P6 B& H% F; c& `+ R5 w内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    8 v) k3 |, ?* J- w
    9 }5 F; F! L9 c! X- O7 h, |不和它 ...
    ! j' ?1 F5 L# N, x# t$ s; @  n
    7 Q, m6 E0 ?2 D1 X
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    8 W8 b8 C/ N. B) d" m3 d后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    9 Z& n" `% n. `3 m7 s6 dvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    2 ?7 L, w# k' F{
    5 X8 q+ h3 E: z8 f        comp temp, xtimesy;
    * ^* m% V# ^) I* o) l  G% X
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。: O! G1 f' @" {
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?# S( G2 d; ]% c7 j' F. ^
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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