设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?9 r3 b, K' \3 L' s% H' d
    4 d( @- T4 }# ?' p
    自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。# K; R. \" f, m& O1 `+ o

    9 V1 Q* l& Y6 V% s速度优化问题真的很有意思啊。' R+ d! E$ x/ k
    8 x# T+ k$ L; [. z1 B
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    3 X8 o7 e. G6 a5 P* C4 h把代码贴上来看看?9 R: n4 t/ w$ V1 w5 X2 X

      c8 \/ \1 \; v# U. A8 r6 S难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 ' ?5 V: |$ ~4 g% y
    数值分析 发表于 2022-9-24 23:04
    ) K1 E, |  b1 }: d) c+ V# C  Q拉下来?拉多少?
    2 Y4 |- S- o/ Q3 S: Z- _- d把代码贴上来看看?

    , G; ~' M9 K1 S6 e, J8 t4 m# y3 X! @$ |! X: A8 R  Q# q
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    . u  a& z, D5 M- r& ^( v{* h. ^1 v' t9 p/ Z2 z9 r4 h
            comp temp, xtimesy;1 c) `- g6 R4 M  U: g8 B
            xtimesy.re = 0;
    - ~% ]8 O0 {9 P        xtimesy.im = 0;* b6 Y0 A, u6 Q
            int j0 = lenB - 1;- c8 b) E: f0 r% B+ j- m4 b* m
            int    i, j, i1, reali;, P7 O0 `: E# K; o# z! V
            if (lenA % 2 == 1)
    * Y7 y  f" K- l# O  x* S' \' w/ }4 |5 f                reali = lenA + 1;) [/ t2 ~1 n2 M5 A
            else( C4 x/ E+ l! ]$ q' v% u; U- \) t) d
                    reali = lenA;/ I  c2 o+ [1 j& J2 J- t! P5 a
            reali /= 2;. S/ m7 p# a( C$ a

    + w) r( h9 U* j0 z+ k% d3 a) m* C6 W0 o        int nconv = reali + lenB;
    5 e/ r  |4 O. u3 T0 h. X( H6 K        //#pragma omp parallel for
      ]( A. b$ S* m9 X! ^        for (i = reali; i < nconv; i++)0 w; ^9 N. }3 N, O7 S  m
            {
    / E% _% Z! i; B                temp.re = 0;
    % [: U2 \8 K, n8 e4 n                temp.im = 0;
    : `7 M3 S1 ]0 x) J) W                i1 = i;
    8 N, H# X8 n$ y( B                for (j = j0; j >= 0; j--)0 u" r. [- a+ {" `
                    {6 c) m* f* v9 Y9 Z4 k
                            /* floating date operation */; |" w, N! e9 T' n% f; v$ z
                    }

    ; R2 c0 w6 [2 ^3 b) ~. e9 {        }
    % m1 O$ i$ ]% _& {4 g. w. e}" e" U& a6 q3 i1 q/ b$ J+ }6 O

    . J/ c  m0 I* s- D/ ixcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样1 G1 {; z) H# s6 n( O$ G

    ! L7 N+ T9 W/ ?* @! Y: q3 v红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。8 ~: a; D( t) Q0 x9 }
    现在call xcorr 100次,耗时78s.' X3 }9 e$ R$ b3 k6 c- ~3 x

    % K, L4 e* Y- c+ J( @& @如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    2 K" H( A. K" ~7 A% w0 Q
    8 o4 H4 V( g- t+ j1 Z
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    # r! f, c1 W5 Y3 U) ZMaybe Debug mode?

    ; W: D6 K; S1 B9 Y+ g3 X! E) U: _5 M$ ?3 K  N' g* K0 e/ m
    不应该,看我上面的回复。( H8 z! H7 p8 E9 H  R" q6 J
    $ @& O$ M% c7 |0 `0 x  i: q/ d
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 + d: t  }* n% [1 x+ o: ?
    雷达 发表于 2022-9-24 23:540 S9 G4 u! Y8 `  F2 Q
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    + }: }# k- k+ ]4 t9 H7 O! I; e{
    - u8 c0 }; x; [; q# T( G0 D1 z        comp temp, xtimesy;

    8 E8 z# F3 ^8 W5 F! |+ O, K- L) M' J% @# C" ]' x
    这个不是这么比的吧。。。
    4 A# F( v' Q& a% g
    ' n5 x5 W% q$ S: y- R% m# Y您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    6 c# c4 k* ~1 C% K1 q) O( B% }3 \' t
    ; @; H4 D( J; T6 s4 l而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 " q% {( h3 Q, B& K' X$ q. F! v
    数值分析 发表于 2022-9-25 00:200 N) C( B, T8 h  P7 c9 H
    这个不是这么比的吧。。。
    ! c' L6 F' h+ q) P, l& T: o! @% O: p' D0 |+ ^$ x2 @9 A
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    + \8 @* g7 T6 T3 [) U; F

    4 Y3 _! B, W% X: l3 \6 E5 h有道理。
    5 g2 M& W! I, G& z1 G$ ~% s3 k/ ^7 D所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。: @7 \  Y1 u0 H/ o) g' p" V0 s

    : c% l& V- z, |0 E. V我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    ) I+ J( H- o4 m" J- a! a有道理。
    % m5 q) l' ^0 h/ ^所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    # e- ~7 K0 R& K5 h  O& v你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多# W8 E& V+ K+ w3 I5 C+ D9 s! P
    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
    + ~$ N+ ~1 B6 v0 f8 V6 f" e这个不是这么比的吧。。。3 F( N$ g9 b* I: u  u8 L6 [

    & E5 I: }' {7 l5 w您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

      V# e2 v. L, L8 `
    / u5 O. g. \, C' j; T4 t现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    ) @. W% r5 a" [' E
    沉宝 发表于 2022-9-25 01:48  s2 |; u3 m6 P6 }. s5 [* p
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    ! p4 G& D* c, ~! Y+ P) K* B! y

    - F; A: D/ P+ n. L  v2 Z6 E1 f是的,兄台说的对。# h; O6 b( ^0 P. X4 M. l( D

    1 g+ X7 ~- A5 \5 k  ^8 b其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    9 y& ]- M& a% H6 j0 G1 I! Z$ k* i8 J2 b7 z& u
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    7 g" Q  v1 W2 f5 f- e, j; p" v! J" ?/ H: }' E8 y: R2 R7 G
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    , n( {* ]) y, a5 x& e9 ~3 Y+ Q, ]2 Q8 U7 e. S
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    & l' i9 K0 D. v8 M) [4 S' o% o
    沉宝 发表于 2022-9-25 01:27
    % k) m  G' y* K7 Y% ^* n, b' p你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    . X9 c$ [: s3 a

    6 A4 A, V- |) _: P8 f. @1 y又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。. v' b! ]) j) t3 K, O1 B

    7 X( H  r7 e1 O我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:472 Y+ m6 f7 Z7 o5 ?4 a
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    # X- s6 ?) \) ^  i1 Y
    时间差一倍的结果可以接受。* a0 Y& W+ M( q' c+ o$ d% E; B

    5 i/ `+ c- {$ O0 |2 h, t你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-28 23:17
  • 签到天数: 1935 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    7 m% l( D: f, J% ~8 n
    雷达 发表于 2022-9-25 04:47
    2 ~6 J, }- O1 q: [$ W又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    2 ?3 h. }6 V% f% W9 P
      ^6 |  W9 j0 Y" Y3 G4 V% k1 ~9 b* {; q

    / T& u$ c) I* S6 I! `能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 8 a9 k5 J, |% |1 r! J* U5 x
    数值分析 发表于 2022-9-25 14:58
    " R# }* n$ S( Q3 f" h能不能把这个也贴上来,看看和上一个有什么不同?

    & G5 a4 \: J4 i( P* W理了理思路,重新做了一个测试。
    1 l" W% E2 n3 o% U2 o! g6 @做了两个 vector 和 两个 float *, 都长 100000
    0 f3 U. C& n9 J5 k# k* M' ?, b外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.8 ?& _" w3 R2 Z' W" c
    : ~1 A+ G8 s" h% j4 e  ~9 A- `! S
    内循环试了4种方法,# C; O; G0 w% q% _2 l1 y
    1. 直接调用 vector inner_product 247s
    5 J2 x* t- |& ?% s" P, o( o2. vector 循环点乘累加 237s$ d5 M& N: [# k. P
    3. float * 循环点乘累加 204s
    + n% ^% o* m# X2 r4. 空循环 100000 次 202s. d( G( H! m) K! W- [+ X- F* Y
    ; }: Y4 Z" x7 F" u* _0 {
    不做内循环 200s
      l) o" y& ~' B
    # e( ^3 n) @" o3 r8 o, m% i" E( D+ ~& a你昨天说的对,内循环本身占比是很小的,大头在其他处理。- p7 @8 ]  \7 _  f( ^
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    1 E% u6 b3 L$ V) _+ E  f  a  K: Q- f9 {9 O! c
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)
      w9 h' a, ^# b8 z; ^  L" E* Y. h( @  @$ n+ q8 @( p7 l0 ~
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    ) \6 z6 F; G- n9 f8 c9 T0 Q" T
    0 C  v$ E" x4 u) K7 K
            std::vector < float > vec1(N);9 O: Q7 b, \: Z9 C
            std::vector < float > vec2(N);5 D/ K6 \6 F* D. R; M
            float* b1 = new float[N];( N( @& b& k8 Z# ]
            float* b2 = new float[N];& e+ V/ ~- i- u3 @2 @
    * M4 f% ?$ m; h4 T/ k* h$ d1 {
            for (int j = 0; j < 6000; j++)
    ; P( G2 z9 {% c) B3 U& \% `2 L* _        {
    6 \  a( `0 k) v# X* }                std::generate(vec1.begin(), vec1.end(), []() {2 m; g- z, f( S+ [/ z
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ' o0 U% e" Q3 ~' @; o                        });
    ) `7 d7 I% e7 f' C# R& r
    7 l/ P1 \8 w7 u5 h6 Z* g8 O0 F. C                std::generate(vec2.begin(), vec2.end(), []() {
    " F/ V: Y" h$ o3 X1 n                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    $ T7 r& D5 b+ p% t. ^                        });
    0 g6 R! T$ H/ r. L; e* {' h; l
    & }: V6 ?9 [. V; w" `                for (size_t jj = 0; jj < vec1.size(); jj++)5 I! }+ n! l1 z1 B& R: C3 S+ f
                    {7 C( P/ p1 n, M- ~' u% M
                            b1[jj] = vec1[jj];
    9 m0 U* D0 D- B) w) g$ Z1 t                }
      ~8 X5 C' I$ C5 v9 }2 {' j6 n. u3 U* ~4 q$ q6 t; N
                    for (size_t jj = 0; jj < vec2.size(); jj++)! S, Y& M5 E7 i$ ~2 U
                    {3 R; W4 ]$ ?/ K4 P# U
                            b2[jj] = vec2[jj];
    . Y, \; o# K( \/ I. C! R  c! H                }$ D) w- @1 J$ w9 l0 E$ _- ?$ j. y

    ) l4 v1 _' p/ e5 n9 S                //Method - 1  N=100000 247s  
    , @# O, B6 Y# A! H8 n                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);; d4 m0 N+ ?1 K4 O5 G5 }
                                    4 n$ `% ~+ u) }2 f
                    //Method - 2  N=100000  237s
    # u6 g; S1 l  P7 v/ f$ }                /*
    2 j7 U  V7 T5 V7 L6 H                for (int jj = 0; jj < N ; jj++)- G" W# o" ]% ~/ J
                    {
    ! S% [6 a2 E# T* T5 b8 @' \7 v& R                        fresult += vec1[jj] * vec2[jj];. A" ~" W2 o/ S) v  u; R
                    }- O4 W3 \+ q5 ]  W9 g/ h/ B
                    */; q* O  F9 |5 O0 S, P$ U1 y! [
                                    
    / j+ E% R& W, f2 f$ S& ^1 O                //Method - 3  N=100000 204s0 K( N& h9 b, z0 l- w
                    /*9 L; w+ ]2 z& V5 W* ]# v) ?2 F
                    for (int jj = 0; jj < N; jj++)" Y; d7 f4 g2 v( R  D4 L
                    {
    4 k, }" \- `- q, x. a, d                        fresult += b1[jj] * b2[jj];
    8 K" y. _2 z) \% l1 B. e4 H                }9 S6 B' y+ r2 p  D/ p$ e0 J
                    */
    . C' s7 T1 o8 Z% Q! y; I
    % k' T0 |5 V7 T. d* j6 i                //Method - 4   202s
    - L2 e5 p0 X4 v                /*
    / v, J0 z3 j6 f9 `) o; v                for (int jj = 0; jj < N; jj++)
    ! C' u+ U' k; ^3 H                {
    2 c$ }/ A$ l& F" q, x$ B                        8 x9 ~, m& ]" _3 B4 Y. G5 Q  u
                    }
    ! J! `4 C! Z" M2 C3 p9 x( J( C                */
    2 C6 A2 N  D# m                //comment out all methods, N=100000  202s               
    7 {* k, F: |9 ?        }3 d( E1 U' s6 v! s
    % K. y6 k/ ?/ X" h( S# w7 u+ o8 T
            delete []b1;
    0 g" c+ T9 H# A* b        delete []b2;

    0 k+ K! `, u( L: j; z, [
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ' @  J, `# J9 S, ?. ?* e
    " A7 `0 B1 j9 ]' Q: v( |你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    $ N* Z0 E" d& i
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    & O/ A/ e  x5 S4 O瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?& c3 j/ ^: M) ?# ^

    , m4 r7 l4 e/ F$ Q0 d你第二个试验里面的j在循环里面又重新定义 ...

    7 ~7 j( x. i: H; F- h内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    $ U8 w: F' X+ d! J2 J* e5 D! @5 _% D7 C, T' X
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    ; v. g6 F6 k' W" z内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL0 I! d. W0 y' i' d5 y

    8 c5 z# B. E+ j, W* x不和它 ...
    : `  R$ L' n% u* I6 H
    # q2 c* c. J. Q, R
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。" i( f# I. n& d2 w* s0 P7 M. u
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:541 Z3 W% z$ w6 D
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    9 n0 Z7 [. e7 d{
    9 I: }3 O" k1 c        comp temp, xtimesy;
    8 K% @% n6 {; Z6 l
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    1 _2 U. ~7 G$ q9 S+ I内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    8 @( u0 H1 q6 O7 |: rVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-8-20 03:22 , Processed in 0.057263 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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