设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?2 P1 U; `. k$ t* I2 n

    ) k+ d7 V* J7 Y- i: X# _2 s) V8 R自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    & k  X6 K" G* P
    + G, A, ^/ L! [% |7 r5 q速度优化问题真的很有意思啊。
    3 k/ h3 K: i9 Q1 V8 F" [0 C+ F) `# P
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?) e% \! g! d# D+ ~$ \
    把代码贴上来看看?8 x! O: \* A5 e5 b) |( J3 w

    1 m+ \5 L4 N$ D& m. ^, z/ A难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    6 f5 g6 g1 h9 D
    数值分析 发表于 2022-9-24 23:04* W1 C5 M- R& Y
    拉下来?拉多少?3 q$ |0 Y6 A& [8 F% C' k$ x& e
    把代码贴上来看看?
    " C/ A: d5 b3 @: o# i

    ' s; g  q+ x9 D+ g) L0 {$ e5 tvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)5 h: b! r3 n, q: O$ b' c
    {: T$ m& i0 n9 K. t( \
            comp temp, xtimesy;
    $ @( N4 U& S, G0 f! f        xtimesy.re = 0;
    ; `6 {9 r4 S. _" Q9 m        xtimesy.im = 0;
    ( E9 S' f, B2 A9 ?0 H0 D6 V        int j0 = lenB - 1;! [2 J8 Q; O" [! }
            int    i, j, i1, reali;
    4 q+ W  c( Q; C" x9 H" h. D        if (lenA % 2 == 1)& I, N2 D" \$ h( z% ?# p
                    reali = lenA + 1;9 ~8 x& f  n; x1 }
            else
    . r; k8 ~8 m1 V0 `% ?: L                reali = lenA;" j( z3 `" x8 r' r* I, t
            reali /= 2;; [& T4 @4 T7 d; C2 ]9 c' ^, M
    9 y3 ~% f  ]3 h' O6 ^/ A/ e6 e5 z# Y
            int nconv = reali + lenB;
    ' e' B+ a, N/ r1 @        //#pragma omp parallel for" }; \, |) G+ y+ R  V' R+ [
            for (i = reali; i < nconv; i++)
    8 Z1 Z+ N0 O/ O" S* U# G0 L4 O" m        {- R2 m8 [. w4 I+ ~9 o
                    temp.re = 0;
    ; N1 y3 g, A! [( E; J: k                temp.im = 0;4 }2 u2 O+ g  [% p
                    i1 = i;/ W& o+ g5 U( Z( c' W- A
                    for (j = j0; j >= 0; j--)
    # i6 ~* q. o- @( h! @                {
    6 ]+ K, t( y" j8 s2 h                        /* floating date operation */
    6 U0 Y' |9 X* @                }
    / {; ?# P, \( H/ r2 z8 _
            }3 g4 I/ Y8 _8 c) l- O% i- p
    }% j( b: \9 r2 ]) L! Q% W8 F
    * r4 x' q0 R# u' s
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
      W2 i& b1 I: s8 r; ], V  O1 `) U0 k4 v. O( c1 l
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    8 l1 r* r' I; {) u' l$ `9 x" `8 y现在call xcorr 100次,耗时78s.8 h" X) P0 a" L5 Y

    ( N% b  J- J( i" j+ R. Y" ]  S/ B5 ?如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 1 E" s7 J5 M  B, l2 q! U8 {+ X

    ! x: Q+ g( R* G. X" K+ p2 C
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33( X% ^9 m. G* K) S' X& w
    Maybe Debug mode?

    ' A, ], ]: b4 C' L$ b  v0 I+ L2 I" D6 m( ^7 f  f; q  R' ?8 E/ a3 i5 S
    不应该,看我上面的回复。3 Q$ s1 ?' ?" o, C! A: t! {
    ! n  d% d* Q* ^4 e& Q( I+ g9 c& D
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 5 K: [4 h$ a1 j# [) M- N# @
    雷达 发表于 2022-9-24 23:54# W8 G" B8 V# ~  S# h5 u# P) `6 G" m
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    8 X9 \5 u, X6 U% R9 x2 [{
    % x- }& z  c4 b6 }* R& t        comp temp, xtimesy;

    ! J, [1 m) R( D0 Y# @. N! C! h
    7 P" G0 Z  g3 s这个不是这么比的吧。。。- E6 \/ X! A) N7 {% {+ [' H

      h# h, A/ h2 x7 d( w您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。7 A+ z/ A1 g( ~/ M

    5 I& F0 `/ W8 m) z) M, Y+ R9 n( k' 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 编辑 . z0 O% n, i" [) f; V0 B, a
    数值分析 发表于 2022-9-25 00:20+ w4 R5 Q- _1 g7 p
    这个不是这么比的吧。。。
    2 @. M2 x  U$ p/ q; [) |  l6 u# f& e+ Z/ u
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    9 Q: |0 G$ \3 n7 d& s3 y) f7 l
    3 V2 @; E4 s6 I/ }2 m; P有道理。
    . ^5 B1 R( X2 k; V. z) {1 {! j2 e8 [所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    4 \8 Y* V4 x3 i- S6 \
    . o" [8 q6 i7 |- C2 {我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    0 J- c6 ~6 J/ s( G$ ~有道理。
    " g0 W; c9 l  U所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    & ^3 n3 E. E) u- v0 ~$ w( \3 I. G  C你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多7 N- s% u# g$ i1 _$ \
    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& U! W1 P! Q: r" ~' l" J
    这个不是这么比的吧。。。. s' j" S3 c, B( h$ X* n' [
    - e* h! e9 X1 c0 P& k- a4 R+ c
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    ! O# ?( Y( m8 f+ X$ r0 D+ g- ~
    ) w' k3 v  I# V
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 5 `7 k) e1 T- e
    沉宝 发表于 2022-9-25 01:48
    ! A; [  l/ h- K现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    - v4 f! W, ^, z: S3 |. Q6 K+ [& o( q& S: K+ o; [: T0 t) p
    是的,兄台说的对。. j5 |- I% F. m) x3 T. {: Z. L

    - L* ?0 k! E# q7 o- S其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。8 P+ _/ R2 S& l) ]: |) K
    . D: x+ G9 Z+ J# p/ X: Q
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。1 T1 @& c) b1 b) H+ j: N/ o  {" o
    ( L8 ]* b7 p5 z% |2 T  h# l
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    5 j1 a3 I- ~+ J8 S) j6 n( z  T/ a  U6 K
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    3 m* s( F3 ~5 q' p3 e
    沉宝 发表于 2022-9-25 01:27
    # g' B0 J2 o4 Y1 }: j& K5 p你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    & a' c1 a) `8 s! Y
    4 p8 B% B- h! V# \
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    2 i4 ^# B3 T7 @5 j2 t
    : \* Y8 \! a: g4 ~, W1 b; ~我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    ) W" ~2 f) v: B* W. N( n8 v又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ; E% n3 y  Y8 {3 ]时间差一倍的结果可以接受。- p* R% m- U, J  q

    + [3 v4 H6 |1 [' O, d2 i你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    昨天 04:43
  • 签到天数: 1942 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    / ]* a! S8 _, u1 n
    雷达 发表于 2022-9-25 04:47; ]  D9 ~5 f4 J% |2 R5 {
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    $ x# k- |& G4 \
    / e$ C5 ~; T. a5 v! \6 y1 G5 l' x
    : b+ Z( |: s) w( X2 p5 c9 N" ?( T! v: V% E- @+ U) J
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    . w- H: z( g3 M' b3 C
    数值分析 发表于 2022-9-25 14:58
    " i2 e6 G$ o& @6 E" C% U9 o: g) a能不能把这个也贴上来,看看和上一个有什么不同?
    " |1 Q/ u% f0 E- R% \
    理了理思路,重新做了一个测试。
    1 h  p- }! n3 K6 K. C做了两个 vector 和 两个 float *, 都长 100000
    7 |5 Q/ v. R& m0 P6 a8 L( t/ L# l外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    8 B6 p* x# W  l- O  L) L( ~8 \, t6 q) k
    内循环试了4种方法,
    3 U4 K6 ~* J* o) B1. 直接调用 vector inner_product 247s 1 z3 [- \8 |& O
    2. vector 循环点乘累加 237s
    4 u3 u& @7 Q6 `! L& l3. float * 循环点乘累加 204s' E% _4 I, U1 v. p0 H$ _
    4. 空循环 100000 次 202s! H9 g: E- }  B. K
    9 ~  Y( N3 ?$ _+ `
    不做内循环 200s- E" Q& n4 E' N9 z
    * m+ U- R- c( X; O
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    - E' Q( X6 ?. K" n! G另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。/ Q/ u* p! i  z2 }6 a

    3 q4 \& \6 o* m1 s$ v% p至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    " J* y2 T0 V7 r$ {/ v( n  I* K% |$ W# l# |& ]' M
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    . R" s: n! J$ G% z( p. B1 N/ K9 K  x1 R* P( g
            std::vector < float > vec1(N);
    0 Z% e7 {3 `! d8 a        std::vector < float > vec2(N);
    8 c/ X* W1 I1 s  z        float* b1 = new float[N];, A) \$ G* X# K& {* B. F: [- k
            float* b2 = new float[N];
    + z6 w5 M& l! P0 \6 X: H8 I5 X4 O- `$ E5 x; I
            for (int j = 0; j < 6000; j++)4 x$ I4 m: k6 I! j; v6 L/ Y
            {
    + h4 o2 V, f, p( l: P5 ~                std::generate(vec1.begin(), vec1.end(), []() {! A9 p" z# [. \8 a+ L$ m9 u* A, w7 L
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;. f- Y& `7 P  _3 b; q2 N
                            });
    6 y0 X# x1 g5 b% q; A; T3 f* ?/ W
                    std::generate(vec2.begin(), vec2.end(), []() {
    9 W2 ~; i; ^* N' Y8 n( `                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    & r0 f4 ^% q, n* |* P                        });& ~" a* A" u* N9 M4 ?5 S
    1 u/ L' _; {7 E& {- i( t7 w4 R
                    for (size_t jj = 0; jj < vec1.size(); jj++)
    - A# W) h9 R5 O9 \+ b                {6 J0 Y+ R  u# r9 o. W" F9 O+ l
                            b1[jj] = vec1[jj];
    / c" B4 O6 x8 p: ]                }  f1 S$ ]8 X5 N# ^1 n' r
    & t  i# ?6 z1 O( F- y8 O" X. Q2 Y
                    for (size_t jj = 0; jj < vec2.size(); jj++)+ R8 Z! H$ P  l1 n  k
                    {
    9 f4 s- C: {$ x  J) ~1 K$ i                        b2[jj] = vec2[jj];% w* }: C" Q7 {5 `$ C: E- S+ e7 \
                    }
    + d2 ?, J" c+ G$ @" ]$ H/ G' |! d. \& Y4 D/ l% D$ {( G
                    //Method - 1  N=100000 247s  - m# w5 p! [& _+ }* ~: s! _- w: O
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);/ o0 O6 W& l: x+ q/ O' Y5 H
                                    
    & M2 s( p$ V/ W. o  v                //Method - 2  N=100000  237s
    9 C+ T5 [- g' ^                /*. _. \+ x8 W; v, A
                    for (int jj = 0; jj < N ; jj++)2 v/ ^& }7 t* @: W7 [" l
                    {2 O' ?1 @. I# F
                            fresult += vec1[jj] * vec2[jj];8 V1 F0 E* j- k- O& `  R5 C
                    }# I7 m: ?7 n7 S# v5 L
                    */
    3 r3 c! f% G) t; r$ I" n                                
    ( d2 R5 @6 {2 F                //Method - 3  N=100000 204s9 _0 W4 U1 B: ?. d' |) t8 O
                    /*
    : w; X. F9 s# A- N. v2 J                for (int jj = 0; jj < N; jj++)
    2 C& _6 f; F/ \! t0 Z; @- I4 w                {4 z) n; U" n% E  I$ ?, D, X; ~
                            fresult += b1[jj] * b2[jj];
      S# z% o' q& w                }" }1 {0 H2 u8 ~! f3 y2 A3 X1 Z
                    */1 `8 \5 e0 E" _. K# L2 a
    " r- {3 Q  ]/ h5 o/ v4 A) O6 C7 H$ W
                    //Method - 4   202s% g6 W3 \, I' G3 U$ j
                    /*
    ) N) I$ ~1 T( [9 O: o$ c' b9 ]                for (int jj = 0; jj < N; jj++)! u; y: R0 j1 J, h$ N! k
                    {
    " [% @7 F) O# v$ j                        1 z% h  H/ C. G( A6 |
                    }
    8 E8 A# _/ y" |% l. `                */
    # Z! X" j" j, P; Y0 Q! B/ G                //comment out all methods, N=100000  202s                4 z& M0 |7 N" L; K% N
            }
    6 ]' R) H) o; n% p9 D2 y$ A" _( j6 }0 ~2 U/ Y% T
            delete []b1;
    ) |% r6 V1 S$ q' p, P$ y: `7 ~        delete []b2;
    . w' P" \/ M/ L9 Q8 `2 h- F
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?$ n( t" r1 }4 L6 L

    / o& g# b5 A% m9 l+ v你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?. B; T, i* `- o. R) ?) H9 N5 V' x
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    * _5 a  C9 v6 P" O3 z瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?7 c, U% x; T6 m" L8 s6 l" j8 R
    , e8 ]" V: o* l1 @. F& p  {1 m
    你第二个试验里面的j在循环里面又重新定义 ...
    1 R5 A# T  g# W5 |
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    5 Q  w1 c! w8 x3 O. N9 M& g
    ' [% n7 a2 e' ~1 ~5 P5 l! S1 i! ^不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    2 N( V6 i- J7 F" S内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
      A% l- j; O# b* i: {# ~  P
    4 Z7 ^* a8 }7 a( S: u不和它 ...
    . Y0 G; L) F% H9 R$ [5 U( s
    / l6 R$ M, N7 H$ d0 k
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    + n# A7 ^7 N. F8 D后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:542 i! b. E/ Z1 M
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    2 {' ]* v7 b: P9 a{" y/ d2 j4 k* i% V/ C
            comp temp, xtimesy;
    0 H0 i9 X) A5 t2 C; m' c7 J
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    , R2 J; e0 ?3 q, x- \" Z* x' T5 a' ^内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?) I+ ^4 @5 r4 Z# d# G/ D1 R
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-9-19 05:35 , Processed in 0.043796 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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