设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?$ k" ]: {$ t3 }) q( ~& ^

    3 t# f- _" p  h; H$ P: G5 c自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    ( v' Q/ d: m0 A( C! N& Q3 d; T, V5 d/ J9 S/ U  X( |
    速度优化问题真的很有意思啊。
    , E" d6 u2 a' O8 g( ~4 D
    ; w+ W7 a: u. h9 M欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1942 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?! @% U7 ^' e8 E: X4 C$ D
    把代码贴上来看看?* p' D% B/ P2 t

    3 }; o6 r' F9 G. 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 编辑 ' m( P2 r5 W) s  g+ S! A' M7 L
    数值分析 发表于 2022-9-24 23:04& P+ d% ~& Z4 K' n2 R' ~5 r: N
    拉下来?拉多少?" u# n0 U& j* |" i* y- G
    把代码贴上来看看?

    4 d6 U8 Y! H3 Z0 V! y& W% R- [, i. X( L! U
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ; @8 D. G4 [+ P  i) ^! }/ N$ I{: b$ z1 E! S* ^' ^  e9 }8 b2 S* \# \3 l7 A
            comp temp, xtimesy;0 J& u5 P' r: o
            xtimesy.re = 0;+ I5 x1 z$ @! N- ^! H
            xtimesy.im = 0;
    3 _9 B4 A$ Q6 s  J, B0 k! j' Q* t        int j0 = lenB - 1;
    ' \; z1 t$ H; U" O: b  N! K        int    i, j, i1, reali;
    , W* N; L  @* D( @) A        if (lenA % 2 == 1)
    ' u2 x2 l& \5 ^, u% e2 h                reali = lenA + 1;$ |* V3 W6 h3 ]' m, o7 S  h
            else2 H6 p) [, g  D5 m5 I( O  f
                    reali = lenA;
    , _4 a1 X% q, g% e. Y. ?% H        reali /= 2;
    9 j2 M4 I5 x" V8 v2 L$ w( R
    ( r- u$ L9 ?: a7 v0 q        int nconv = reali + lenB;, X; y! }( R9 \
            //#pragma omp parallel for' l8 s' B& @5 r3 F7 t2 x3 p
            for (i = reali; i < nconv; i++)
    ; o- g- ~; ^7 a% F        {" \; V- n% y6 l5 R6 ]  G
                    temp.re = 0;
    + E4 l* u; B. s5 p. C9 e                temp.im = 0;
    ' ]9 x' u- ]. `, a6 G                i1 = i;. s! X. ~" r4 ~, k; O( d
                    for (j = j0; j >= 0; j--)1 Q3 j) V8 s4 P* V( u1 `
                    {5 e/ \1 n0 i- B* w
                            /* floating date operation */! U, K$ x6 N# E5 D5 @" [' t
                    }
    ! b2 N3 C: M. Y) _  {% h
            }
    6 d( Z1 a, x  b- x( r}
    % Z, F# O  Q( K* R1 U5 _9 M& Q5 ~( E2 t; C2 Q& O
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    . A( ~  m/ m6 s. W6 X" z6 {
    9 t8 y0 q- C! S, s3 r红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    8 a- v8 j, w  _4 h' n  a% {现在call xcorr 100次,耗时78s.
    , N+ i$ R5 e- i9 W% K0 j5 g
    5 {$ M2 Q5 O! S  n如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. ' C" o6 ?# s' _6 z6 {+ Q  o) B$ Z
    ' p. M: O7 j3 ?" W1 Q& M! g+ H  j
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    , O1 V$ z& p' h1 d3 J1 h1 AMaybe Debug mode?

    ' S! N2 b2 ?9 ?9 @/ h% X, T* m! w1 p& t1 {1 F' b, Y( v: K, h2 C% H
    不应该,看我上面的回复。
    7 _) _' x: x7 W" \3 |. p/ Y# f
    . |0 K5 u/ a+ _5 q/ f我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1942 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    " V* z% r' w4 {! H
    雷达 发表于 2022-9-24 23:54
    4 z/ m+ ^  [5 V+ X% |% L7 p) ovoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)! v" w! d2 @+ h( t5 m
    {
    " s3 V# J8 r6 c1 {: i! A) B- W$ r        comp temp, xtimesy;

    0 D1 y) T: [7 D  ]0 h3 Q2 g0 z; W# L& e; z) M  |& o  G
    这个不是这么比的吧。。。
    $ M) b$ {- q& d7 m
    ' f" k6 S; ^- y0 N2 T您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。( X% Z5 j- N- V$ G2 H

    8 w4 R5 V9 R6 r% \( `而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 5 s- H4 f" r0 ?; P. q; c
    数值分析 发表于 2022-9-25 00:20
    2 a' y% N9 D6 H0 X  P0 t! z这个不是这么比的吧。。。
    7 ?; Z% _# A; w( B: n! ]4 W7 J* L2 l4 `  ?  b  v5 v7 j! v
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    $ U5 J0 M. X/ e! J
    - }) E3 y. n* a" ]" `8 ]有道理。0 Z0 T8 ^6 A/ }  a' u
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
      b/ w5 A. Z& a9 D+ v2 {3 I
    ; A+ y. M& h! H/ D5 H  x# V/ G我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:462 C0 [2 |4 n# s1 W* x. F
    有道理。- L+ G  ~# M- H8 S4 n& M6 S' i
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    1 o& S; D! s! q) R; l+ ]. H你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    . ?2 o3 b  ?: F) q& u5 {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
    : @* \3 S; p) t# ~( l4 A! N这个不是这么比的吧。。。- C% E6 g" Y% b

    , e4 @8 O9 u9 Q( D您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

      U" w) P" X" m
    $ _0 P) t" f7 I, ~& N现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1942 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 1 j& ?/ Z% c& g9 N
    沉宝 发表于 2022-9-25 01:48
    7 ?/ K# O6 ~8 v9 r: F* Z  t现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    8 w" P7 a9 a: Z4 ?7 S1 i

    + \6 N: ?6 }) ?3 t9 B6 L6 Z是的,兄台说的对。
    . Y3 w& O, I9 I% _% T* F$ E5 D2 w( {$ Q5 I: Z0 Y
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    0 H( C" {0 A" R2 F# Q9 @
    6 o7 ]0 M0 _; m2 {- @5 |/ K雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。" _$ j: O5 ]8 s4 c9 s9 G& _

    1 V- k8 Z& k, A" {. e: M比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。% N# b  V) e! H; B  G5 d
    9 |+ _0 t; d: O& P9 v
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    7 r3 \5 ~) p0 p
    沉宝 发表于 2022-9-25 01:27% O) k+ m! K7 @% I5 W+ f& N1 S
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    2 l8 I/ U6 m( p' u+ p5 K
    0 ~/ W7 f% Z5 p" W: u
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。+ X( X$ n* Q8 E7 R5 C. N
    5 H! r. S! e/ q
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:470 c/ x' n$ v2 Q' ^) c( F9 P5 n
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    " J% M5 }0 I3 f$ D# j0 W2 u
    时间差一倍的结果可以接受。. K, V" J0 y+ @
    & b1 ?, b) t% r3 W
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    3 天前
  • 签到天数: 1942 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    ( R2 K% H* J8 T5 W
    雷达 发表于 2022-9-25 04:47
    3 v8 h$ C$ k/ B2 F: F$ i又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    ' j2 S8 k( }* V
    ( g! L9 r" }+ l5 w
    " ^! l, n4 n/ V9 M! r$ h0 h4 S6 k8 L$ Q% c  |. N+ ^8 @: D
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    5 E( S+ m8 p" e* w  w. ?
    数值分析 发表于 2022-9-25 14:587 a3 w* \2 w1 r0 W
    能不能把这个也贴上来,看看和上一个有什么不同?
    ; ^+ v, {& p& ?( e
    理了理思路,重新做了一个测试。$ C% ?8 ?" d8 t: N0 D6 ]# k
    做了两个 vector 和 两个 float *, 都长 1000006 l" {& `5 ^! {4 A# ^
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.1 U) f9 a  X: L, E) U6 v/ I
    2 M5 a- E; u( a( c5 C: L
    内循环试了4种方法,
    7 x7 b2 M  r" B  N: O- W: c1. 直接调用 vector inner_product 247s
    ; E2 G5 H1 P& M  d. }2. vector 循环点乘累加 237s: t1 G4 J* c9 Y: {( q
    3. float * 循环点乘累加 204s: p. O) a6 w. [: I% Z- f. L7 \
    4. 空循环 100000 次 202s
    - \( }9 {  L  o4 I; }# L/ ^/ U( _. R4 p& G; ]
    不做内循环 200s
    ( d4 t2 J& l  i# P) i- a' n5 S7 \; n- ]7 g+ d5 \! ~3 F: l6 N
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。8 n3 e& C5 a! e/ n9 {  T! O% g: u
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    , z; h" R# l, K# d, K8 H7 q5 u0 e; z  E0 Z
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)# X5 i: G) _: U1 s/ j6 Z

    % O- I1 U  m$ }3 N8 \; Y(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)4 g1 ^" a9 T4 P

    : w4 F- W% w# k! c5 |
            std::vector < float > vec1(N);1 C" B# s9 H7 E8 d! Y4 s+ R+ ?/ g
            std::vector < float > vec2(N);3 @+ B! g/ w0 M+ w
            float* b1 = new float[N];! d4 a" r2 {4 C3 u! k/ t. w. Z
            float* b2 = new float[N];
    4 I) i! L  h* c* O/ [
    + a1 q% [+ B. ~6 v+ j0 u        for (int j = 0; j < 6000; j++)
    3 i3 V9 ?- P; D% x9 R        {" D: J- _5 Z3 J1 y" I) D/ U
                    std::generate(vec1.begin(), vec1.end(), []() {) w7 m. M- C" z
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;2 ^( B, {, K$ c6 @% q0 n
                            });$ A% Z+ D. s( I  [5 R( a# }

    : L  w! m) ]$ L: `; K                std::generate(vec2.begin(), vec2.end(), []() {
    . _" r( a1 \* {9 s/ X5 D( r! \                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    ' E( n: V3 g! S3 ?+ Y8 s                        });  |" |/ N! t* |6 g4 G- G# W
    , w* d0 M& i  x+ g
                    for (size_t jj = 0; jj < vec1.size(); jj++)+ ?% ?' y9 U  u. c" w
                    {# i# {2 G* t8 }; y% R& F: }
                            b1[jj] = vec1[jj];
    9 w4 V, c9 O: K# Z3 L; D                }
    - I% h3 P( c! D! |; h0 {
    " u4 c! C8 a% k( i# K                for (size_t jj = 0; jj < vec2.size(); jj++)( v( z& w( l  @. s) ~
                    {0 @+ n! U) A; i  M; h& s
                            b2[jj] = vec2[jj];6 j2 z* d4 ~! T3 n: P! n- i1 B* i
                    }; F" r+ x4 I5 V7 _; T3 y

    - B( c4 D- {0 T$ y+ i: p# w9 w                //Method - 1  N=100000 247s  % s8 y' u  D5 M
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    " C7 g6 |  b3 _+ ]4 j% S1 M  P                                
    ) I+ j# c# J2 O, T& D! ^4 u7 m                //Method - 2  N=100000  237s
    4 b, I6 x" l5 Q4 s) ]7 y                /*  t5 S1 o6 u$ T8 t
                    for (int jj = 0; jj < N ; jj++)
    0 |: @4 b4 @  Z                {
    0 i* M8 e) @3 f& l                        fresult += vec1[jj] * vec2[jj];5 \& ?  I2 s; j9 t: j& n5 K
                    }
    - O& w$ C5 s& L% s4 ^% s# f                */# j; f0 H3 r, l
                                    # ?5 W4 a& v1 Y+ W5 R' j
                    //Method - 3  N=100000 204s% T  @7 M. F9 `# t2 G
                    /*' k- P& Z8 ~, d: G# c
                    for (int jj = 0; jj < N; jj++)
    7 x) t" x# H( L! Q; ^9 }  t                {
    ) h+ k$ Z: C4 U$ g                        fresult += b1[jj] * b2[jj];
    - X3 q, C6 O! ~, d" |                }
    , |6 m+ b- W1 g* `! g/ l                */7 m+ Z/ n  Q/ ~- V5 R: @- M0 ^

    ! J3 ]& _, `5 U, y2 V. W, m3 g                //Method - 4   202s
    6 h1 i$ P5 l+ e' R4 Q+ x                /*
    3 a! Z; u! L! e+ f5 S                for (int jj = 0; jj < N; jj++)- H2 k" Y, W  u0 J9 ~% B
                    {* p0 T/ c3 @! `0 J2 c
                            : F5 @* h& s3 V$ l1 D/ u6 S* m4 M
                    }
      O- A6 m$ P$ n1 J2 F- U! s                */
    0 U% c9 n, e( j2 m2 b# S9 v                //comment out all methods, N=100000  202s                , B5 _% I1 m8 e% h+ u& J5 f
            }
    ! y! N1 F$ k  J
    / I2 ^6 O3 P" }7 F  D3 n, Y; K& m+ V& n* k        delete []b1;
    " N9 i! w' D. ]        delete []b2;
      i, I! w. g% j9 [" c4 E
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    & ~2 i6 Y5 B2 s1 C: \  @7 x0 p9 M+ i" r, [0 {) t' }
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    2 l+ o' J# k9 M
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    : b  u8 N7 v" y6 k  V" m7 z; K瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    2 G: p+ g# p( u$ {: a0 x( @& M* H4 e% x
    7 @6 T) c  }  K) s你第二个试验里面的j在循环里面又重新定义 ...

    % J  q4 e# L# G7 G) r4 ~, G内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    9 d' ]- a. }# J) v; e# [
    3 B3 x5 ^8 H) x, _1 Z不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:168 C+ k, {' E; C, n; X& A$ _
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    7 M" O. D1 n5 I. L: o& f* ~1 F6 p
    2 N7 e- N+ x9 H* B不和它 ...
    " P* P/ T  n8 e% {( M
    + H& Q/ l9 P/ `, P7 u
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。1 d% s7 K3 Y+ R1 H3 i: F& E
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    / a  M& ?$ ~$ m) T8 Jvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    9 N% A- R3 P! Q/ h) ^- J{
    0 O9 d" g& m' m4 t8 f6 O8 w+ g        comp temp, xtimesy;
    & |3 H3 e* p2 a: `5 H; |
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    ) ?  \/ d$ t4 [) J) B5 F. b内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
      {+ S) d4 t, {& q( L9 YVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-9-21 12:51 , Processed in 0.050360 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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