设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?* U2 D$ c2 W7 U/ H2 p; I& `
    / n1 h* U" R; l7 o! Y5 C: P$ y
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。, y$ y4 L2 v: i7 a

    ( f- Y/ ^1 ^' E2 |速度优化问题真的很有意思啊。. [! j* a  B/ U0 Q! r

    / q. k% w3 V' N! ~; Y欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?) m. Z0 W0 O! v/ e
    把代码贴上来看看?0 m  h9 o6 ~* U/ `2 f

    9 K4 w5 L4 J2 v4 K! b难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 ( ?! I& i$ v4 m$ m
    数值分析 发表于 2022-9-24 23:04, ]5 P9 W5 H# j: c9 i% R
    拉下来?拉多少?
    5 C$ M8 d0 N! d7 r1 z( A把代码贴上来看看?

    $ k8 O$ K1 k8 o( u6 E$ _& l# @) P& _+ _( W6 q+ h
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)) p  g) G1 J( E* s
    {
    4 d. o4 X' V& e9 I        comp temp, xtimesy;
    " g9 s' t: J: ~$ G( }        xtimesy.re = 0;
    - H& F1 F0 |4 o        xtimesy.im = 0;
    " P4 E! I  J, Y% K        int j0 = lenB - 1;  B$ }; |+ {6 E; s8 @
            int    i, j, i1, reali;3 a" J5 b4 B; ^9 O, m
            if (lenA % 2 == 1)
    $ J) Q. Y( G" n! _9 I  c3 `1 ?                reali = lenA + 1;  C8 A6 n( L' x5 U+ |
            else; X- g: s% s% X3 x( t- L
                    reali = lenA;7 k, u/ B0 u7 T+ v3 i
            reali /= 2;
    # \$ r4 u* e9 J8 g* t) k
    3 e* G; _- {7 u8 i9 k        int nconv = reali + lenB;% Z3 O7 ?. m, S2 A  c2 s, a$ O% g
            //#pragma omp parallel for
    # o  `1 T7 ]4 t! @# X- t: C* l        for (i = reali; i < nconv; i++)
    , k! S  V  G6 R3 N+ G; j        {2 S* Q, @; A9 O1 X% I
                    temp.re = 0;
    $ [" \8 r. V: G1 [& ?6 u$ `: B                temp.im = 0;$ y, B- A. m8 a2 f
                    i1 = i;8 {0 J& M" q9 t+ F+ L: `$ N8 Z
                    for (j = j0; j >= 0; j--)
    5 l, |7 k$ S8 C/ y/ [                {
    2 h# t( G# P  B" R9 h                        /* floating date operation */
    * ^- f1 O; D9 k8 v+ k1 G                }

    ) z0 q' K* D7 y9 n1 `5 C* E, C        }9 X/ ~+ h: a! r3 Z! W  T
    }
    ) P' a( v5 I) I+ S6 Y  D
    $ J9 O$ b6 \+ I, B* C. H2 `xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样) ]& f3 \3 |# F3 I& w+ O) X. x2 i" k

    3 h. [* }( D# ?1 e红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    , q, }7 F; B$ `/ Z/ W# ]) I现在call xcorr 100次,耗时78s.
    5 J& B8 M, V) a3 U+ m6 |: m7 ^4 p2 j* H4 H$ ^- J  i3 T
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    1 T5 d( i" l0 `- k  M) M8 o8 q
    8 t+ N$ ^6 ?. ]' v/ _( s
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    - `7 L: _- r9 ~, p% @, c" g# MMaybe Debug mode?
    - \3 h/ \5 P9 ^% m- k

    % |8 s4 ?- D6 ^4 o3 h不应该,看我上面的回复。
    , F0 ?& S- o! ]6 p6 s2 W& h( H- z5 ]7 |) g  @+ q
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 1 E9 D5 y- ]. @7 L( c( \5 u
    雷达 发表于 2022-9-24 23:54
    6 B; G1 m- V, A9 m5 `' o/ r, Gvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)/ u. o9 ^0 \( i4 l
    {
    # `- p7 n( {( s* S& u. W' i        comp temp, xtimesy;

    + N7 x: k$ t4 O% p, c$ }+ F3 q: N$ I8 w* y
    这个不是这么比的吧。。。% K) o4 A0 t- ?

    " D- v" {8 V5 t8 L  o5 h您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。# H5 [; L. g9 l# [  c! b" ]2 Y

    8 ?/ z3 ^* X1 s. ^6 `( W3 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 编辑
    9 ^9 g! |: z9 k- _7 p9 X/ a
    数值分析 发表于 2022-9-25 00:204 Y! B! }3 b3 }
    这个不是这么比的吧。。。
      Q+ b; G7 l  K8 y6 _# K: m
    * J. N3 T: [: ]) P0 N% S您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    . V; }) K, f* O! }+ D

    1 Q( V( I6 w" e' L0 x有道理。: x1 V! ~- I4 I# F
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    ( w  Q! @" y. B; A2 \! L8 E) O2 j" Q( {5 c7 |5 a9 G
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    7 j' H) J8 {  @- @" A' W0 K( _有道理。( y; m1 _8 O( `1 v- z  z$ [9 M
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    3 _# ]% @* Z: {- J3 j
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多% W5 }6 R$ j6 M) q4 v5 H/ |
    Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:208 F! Y; H/ m$ S4 z+ F: V8 i" c5 K
    这个不是这么比的吧。。。: I8 Q' T& _0 b" l, G8 A: |- @

    6 ^4 G7 D  W: T6 o1 O! J7 [您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    4 |; M6 S8 l+ u; @' u' x# ^: B
    5 `& @- e$ W! Q8 E# o* B现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 ' y  d' x& y: B6 |; q' U5 b
    沉宝 发表于 2022-9-25 01:487 ~8 D+ F8 U9 l7 C$ D7 f. D
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

      D! O3 L' }. q* g% `7 M, B: X% `. R: d& M) O7 N1 r
    是的,兄台说的对。% c! Y) U) ]  f3 B/ Z' _" R$ f

    & u6 M7 a4 B% C  [, u" A5 a其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    3 u5 B* N8 z) \& X, @  Z0 P4 j% {1 i( a% z$ D4 w% Z3 V! u4 p# F: }
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    ' C4 P3 E5 z+ h4 a3 p, t/ d' j9 J" c+ O$ D5 C" I5 \% M% Z) x( @4 M- m
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。5 M3 e2 @" Y4 l8 N- D
    6 S8 Z$ V0 Y! q
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
      k9 A8 v- G* w8 I( c; c4 P0 F
    沉宝 发表于 2022-9-25 01:27: S9 A4 G, `& [4 F# N1 b$ |
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    # B- W2 \2 W  I$ w* z: e# C% B
    3 Q; Y4 x7 e6 X7 A5 V又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。: S$ b+ u( z0 y% i

    ( c  R) E9 U+ A1 D$ s1 P我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    3 P2 u: H& h' ]* Q又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    6 Q8 Q# w. C5 |/ r& V* |* Q时间差一倍的结果可以接受。
    5 q2 ?$ Y: p  }
    . I0 O, B8 u) ^0 _! q7 h. [6 Z2 @你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    5 I' O" B- {7 ^2 ^5 {
    雷达 发表于 2022-9-25 04:474 I0 x2 k3 i1 \7 ^. D
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ( }& M$ p6 q# V! \) s4 o% A- s
    . u2 R+ J% T( s4 U( [* r

    $ p5 p% ?5 o" c' ~8 R0 r
    / V" F2 z" @( E3 M: K能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 % ~8 g1 [. P8 M1 m$ P. @
    数值分析 发表于 2022-9-25 14:58
    ' @% t1 X" ]; E" R3 l能不能把这个也贴上来,看看和上一个有什么不同?

    # o/ v& h- s9 U理了理思路,重新做了一个测试。# x) [& v  M' u* \- ~, K: |
    做了两个 vector 和 两个 float *, 都长 100000
    9 Q' r: l, R2 t3 c6 K外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    ; f4 P5 @- y2 R/ T: Z: Y1 \" u3 |- \6 _" n' `
    内循环试了4种方法,5 u5 Z5 l1 O' E$ ^5 s' L
    1. 直接调用 vector inner_product 247s * g9 d& a$ F* K6 g
    2. vector 循环点乘累加 237s
    9 G9 e+ \3 i$ {2 C/ ^( F! T2 m  i) v9 W3. float * 循环点乘累加 204s1 H% l6 z5 E3 `6 V
    4. 空循环 100000 次 202s
      E% w/ C$ B! c) b2 f+ o
    * g+ v$ J: n$ ?1 K3 o0 |7 X不做内循环 200s0 ^7 H/ i( l' w% W5 Q

    & m/ ]1 Y$ P( Y% m. p你昨天说的对,内循环本身占比是很小的,大头在其他处理。1 x1 d8 E9 O2 d8 v" |; z
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。. H" k  N  q, X2 v* G
    $ v8 \8 r( P  ^4 [/ y$ i
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
    ! f" M' r" i3 ^) `% h6 W" @+ f% G% ^7 p: }2 K; L
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    0 |- T+ G, w& l; i6 u/ U0 B! o/ F8 O4 m* K; {
            std::vector < float > vec1(N);
    1 R# |3 f. v- p        std::vector < float > vec2(N);
    & {* R' \; p" ~; e' v        float* b1 = new float[N];  `- _, m8 C3 {
            float* b2 = new float[N];5 y* A* p' Y: @
    + H, A( `. s- k# X6 G
            for (int j = 0; j < 6000; j++)
    1 w# Z0 t' q9 b6 b. A$ m& O        {  W5 _- X( u: M7 {8 E7 X
                    std::generate(vec1.begin(), vec1.end(), []() {
    $ @- o* C) m) P, d+ P                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    5 V+ u, ~; ~: U# n: F4 D- k: N1 H                        });/ U, A$ Y9 O. m# ?

    : x6 }) l* K% U" g                std::generate(vec2.begin(), vec2.end(), []() {  p! l4 ]1 I9 F+ P7 C
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;+ A* s. u' ?" J6 Z: Z$ d# ~
                            });
    ; {8 g) U5 g+ p+ Q  r. {& ?
    3 ]3 L5 X+ ]/ e& N7 c" ?' ^: e& F                for (size_t jj = 0; jj < vec1.size(); jj++)
    " {! q( j4 H) S$ p6 n                {6 w+ Z' E* Z) N- U# \( |, \
                            b1[jj] = vec1[jj];4 h8 J( G" O; v. o
                    }
    ' u- C9 I+ y) \8 o/ _' u& U* G/ N
    6 R$ D" v0 ^( q$ z                for (size_t jj = 0; jj < vec2.size(); jj++), b9 B  `! K: v! {
                    {
    ) E) ]2 T4 U* o                        b2[jj] = vec2[jj];
    6 H5 A) [0 G: J9 J* F9 w  d. [: I) @                }
    7 [8 @5 X/ s2 {1 @9 W
    - `/ E2 R% @4 v% C                //Method - 1  N=100000 247s  ) g: n8 X- U0 H+ Z: w4 x7 A
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    / T6 {: Y" h: {7 A, G  y                                ! `! p* h0 s5 k  m# n9 P6 F
                    //Method - 2  N=100000  237s
      K# G" B' u# _$ {% a                /*5 N. Y4 M% Z, b3 T' ]& l
                    for (int jj = 0; jj < N ; jj++)9 n! c% v( H  g& k/ C. u, W
                    {
    8 y9 a* {& K+ n9 v* z; X                        fresult += vec1[jj] * vec2[jj];
    : |% ~5 A* U: i% S  R, B; C* J9 z                }
    * S, e4 ~) H$ R. R3 \                */
    ! {) R2 C' M$ _, \& Z                                
    & _. A) i- ~3 M, j7 E3 Z- Y7 [/ A                //Method - 3  N=100000 204s
    ( B4 U9 {8 |7 j2 n  q                /*# y  f" {6 o5 H! L, M/ T
                    for (int jj = 0; jj < N; jj++)
    * e$ Y# L: D" @# ~+ W0 ]                {
    ; ?8 {; x$ E3 J3 \                        fresult += b1[jj] * b2[jj];" d: ]7 g+ C, k2 o6 V
                    }
    5 ^$ t3 t: h2 r& [                */
    " I/ Q5 D) m" v. b
    ) r- v0 l6 y# u2 D" _  F; c, z' _                //Method - 4   202s( Q" y+ j* j9 H8 Y4 U2 L3 {' k$ K
                    /*) f' ]$ d& a% |1 Z, J+ U
                    for (int jj = 0; jj < N; jj++)% t; T4 j8 |9 ?* b, i2 ^. [, k8 i
                    {" X% ?  c  }9 C- [
                            
    ) F- T  F: Y7 }* o  I  h7 f/ n                }' i! f! i; M5 B0 ]+ h+ {! M2 c+ P
                    */9 A8 |  a( X, [5 _
                    //comment out all methods, N=100000  202s                , j+ {" p1 s. k8 _
            }0 @# _5 c! Q% s* H

    0 c3 ]# h0 J* I6 ?+ {, C% E' s        delete []b1;
    0 O- _: n* O( R% i+ x        delete []b2;

    6 c$ C6 v  `/ v, ~
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?5 [, ~  @+ f( j9 `; w4 L
    * g* ^" Y$ _. i
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    * C, u) a2 K- Y7 w; R
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    / R+ E3 i  i0 D6 X瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    , o2 }* h) e4 N+ d0 C) f3 |
    / R2 Q5 Y, X( r& [5 |7 r5 J你第二个试验里面的j在循环里面又重新定义 ...
    2 X8 z. r3 Z8 G2 M6 D) p$ C% \
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL, d8 G7 H: J" Y8 s' @
    3 Q$ O. N9 N8 F1 v- G2 f$ ^
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16* C  {& R: B7 E& N2 n
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    8 w; ?) f( \2 A. k. \8 B# Y3 e# P' z) o
    不和它 ...
    $ B6 l2 Z, P- f6 i) O7 B0 A- Q& E
    ( [; k9 j7 M+ H: e, G
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    . N2 D* A- @9 w' o: V4 [后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54: c/ {# U. P; y' @
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)' n9 b! I  ?6 Q5 e
    {1 g3 g% J3 ]2 U1 p5 A
            comp temp, xtimesy;
    % F9 c: S& e4 X+ g7 \% H. c! A" B
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    ( ~; G& w2 u5 ~内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?+ i6 w# h! x$ L' [7 l! f9 h
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-2-19 05:55 , Processed in 0.057973 second(s), 22 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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