设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?* v; J6 v9 k- ]: h0 V) J. X" X

    9 [* K7 x$ A7 g4 U7 s6 |( X- {- w自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。
    4 e( d( p* p# v: g
    . W9 Y" P1 p' s6 Q' v速度优化问题真的很有意思啊。
    % o, |) S6 ^, C  k$ ?& e6 a( X9 T$ O+ J( p( `
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    12 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    & \7 K  r; w4 I( s* n$ q把代码贴上来看看?2 y( C" K9 m4 y8 h( L
    * u5 O7 v/ l! H  N8 d
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    & l8 }8 v: a% n6 d! N7 p5 b
    数值分析 发表于 2022-9-24 23:04
    ' L1 s  B: _$ X0 F  b) b5 d5 G+ L拉下来?拉多少?+ {* f  w' I, }) F
    把代码贴上来看看?
    3 n, U! Y, @* [, Y
    " p" m. ]- ~" h
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)7 L1 t* ~" P; I/ R
    {
    1 V2 _% N  e: a" D6 t7 o' }  Q( q. I4 l        comp temp, xtimesy;0 i& X( _/ B0 ?
            xtimesy.re = 0;
    * T7 v0 D6 d/ i1 f. N, V        xtimesy.im = 0;
    # h# M  e2 T$ d( K5 }        int j0 = lenB - 1;
    2 D% h/ S. Q# D( H        int    i, j, i1, reali;; A* w: n" X0 N! X4 v
            if (lenA % 2 == 1)
    5 R# a5 x( k  m9 k& b+ f' |                reali = lenA + 1;
    * L0 N0 e: a  D% f9 ~        else
    9 O' J( \3 _7 O6 f                reali = lenA;5 ]0 l" [! K( B  U- j
            reali /= 2;8 O% L4 d8 ^; O7 T  ~& b) E

    ; _4 o! t8 `2 y3 ]        int nconv = reali + lenB;- s1 X+ J7 _2 }% a4 Z# S
            //#pragma omp parallel for
      p/ D$ H  }5 Z        for (i = reali; i < nconv; i++)
    / d7 V. x8 D1 t+ M        {& R2 j. P1 C+ U0 r
                    temp.re = 0;
    , ]) `( T+ E" [  N                temp.im = 0;7 O) k: v. @7 O
                    i1 = i;
    ; Z! a6 t5 |9 U! a6 C" T( \                for (j = j0; j >= 0; j--)4 y. S$ o3 L/ c
                    {9 R+ B3 k) e1 a3 W) a! n
                            /* floating date operation */
    1 _# P' f" Y2 Q! L/ l                }
    * D( X, R# z, m9 t+ j
            }+ L( b6 t5 w, y' a/ @* D3 `; o
    }5 ?& B6 o7 y& ]+ h% `% H  p' p

    ( N) i' X( b3 B+ a# P- ~1 ]6 hxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样) x. D' P$ `( [+ ^, s
    " C7 M4 l4 T# G4 p' C# T* `
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    , }7 N. i4 j0 J' c8 t: T1 |; Z现在call xcorr 100次,耗时78s.( z* i" T8 r9 h; q( e# F

    - `# G' R) s* r/ \- A如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s. 5 v4 A/ }0 {4 Q9 c
    ( P, I. I+ E. `$ [7 n1 Q
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    2 w+ F$ g- D( n# p! r9 nMaybe Debug mode?

    1 V4 t, j5 v4 v$ Q3 Z
    1 W& M/ C$ Q. j- R4 P6 x+ b不应该,看我上面的回复。( j  x5 L0 n( ?* \: p
    4 `8 D9 f0 P) L6 D9 U1 L
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    12 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    0 r/ T% ?. M2 K; _% T. ~
    雷达 发表于 2022-9-24 23:546 V- v( s' _5 X# l
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)  }. u5 w' R( }% D9 K
    {0 O5 {8 A* Z" i2 X4 k
            comp temp, xtimesy;

    ! m1 H" i$ b$ S; k" G  d, m0 R1 ]  }0 Z& H% q
    这个不是这么比的吧。。。
    / b5 f3 ^! E' F# ^: u# c/ c4 t6 ?/ O% w! Q# R2 X/ V& L$ `# M
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    + r, g0 x4 I# K6 V2 [7 t
    , ?# L3 w" s$ }4 b4 y而加上内循环,光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 n( v& S" {7 d+ Y' k: x8 O
    数值分析 发表于 2022-9-25 00:20
    0 m: l. i, F% o; O! L/ ]这个不是这么比的吧。。。
    6 H9 L+ B* t0 X9 v% \9 |
    , z0 I+ W1 S3 V& x3 c% [+ I% E您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    ' ^9 r' [* R; Z$ c" {" p1 Z5 U8 j. P
    , e/ i  N% e9 c& h/ P& m有道理。/ J) D0 I' H5 t+ j
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。8 n/ K2 b# ]+ y8 L5 c/ K- E
    1 Q+ q: k: s3 B7 S
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46, I* X" Y( L& M3 w
    有道理。9 L% Z1 M2 u% {4 g. Q1 N$ {
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    / [, w) O4 M/ F6 s9 \% h
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多& X% x0 q/ u( D. Y; L4 j; c2 \4 d
    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
    / R# v# X9 y# V* g& R( L5 I3 q这个不是这么比的吧。。。
    0 N. g( L6 z+ ?2 b" Q+ G6 C% n, Q# Q* Z4 R: J1 K1 g' G
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    6 Z% }" s! i( t: }$ |9 }
    # o; n/ \$ Z' \; R0 L* p( \5 C
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    12 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    2 ?; G$ t; N8 H& m  S
    沉宝 发表于 2022-9-25 01:48
    " v0 o2 u# P7 a- @% ^, ~1 P# K) g% P现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    " e, K& G/ _8 s
    . @- r5 _! ?% r; o6 `是的,兄台说的对。
    ! }, t0 [; C  T. U+ `8 t
    + M  z9 |+ b. y& t其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    4 _4 O, m$ A" s# C: ?' [& S% s1 Z% s( y  R7 c& F3 G( ?2 r$ W
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    & ^( h" e2 f( q/ k9 t1 s) H# p7 ]" ^8 Y, q9 P  m
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。: C$ y: P/ @' R. ]. s% n1 e

    8 p. d6 c& o3 k$ y当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑   g9 \- m* G  L0 S
    沉宝 发表于 2022-9-25 01:27
    % _2 a7 H9 ~; n0 `& ~你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    9 A9 X8 q, M" v2 w4 D- Q

    6 K  Q- I: y! ]. ]/ Q又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。7 x6 A% Y$ `$ [) Q
    % m9 j4 k  H1 g, B" U: c4 Z2 ^/ h
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47
    " H7 n- q5 U- g. V. a% k又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

      c6 M8 _9 P2 s$ K7 M* G时间差一倍的结果可以接受。
    8 F9 x7 \0 j  F' n4 `3 w5 B2 L
    1 {8 L: E$ @* |+ ]3 L% P你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    12 小时前
  • 签到天数: 1873 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    8 q0 m4 F# o/ @8 `/ w/ ]
    雷达 发表于 2022-9-25 04:47
    1 i7 T9 E" W  A3 j- w' g# L# a( u又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    $ {0 R+ E) ^5 P5 o4 D, T- ~' r
    % o$ i+ x. P4 h- `1 E8 ^
    / T1 B* ^9 M, S0 G2 Y
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 2 l4 x" ?7 n9 a1 Y' x, I- m; f
    数值分析 发表于 2022-9-25 14:58
    % i: l  {0 c: y1 D能不能把这个也贴上来,看看和上一个有什么不同?
    2 N* u/ Q) S; Q3 ^/ k/ y% J
    理了理思路,重新做了一个测试。1 K  x# u& Q$ Q$ N) L: ~6 v
    做了两个 vector 和 两个 float *, 都长 100000
    6 T+ J: h) ]. A  Z. h- o外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    9 P3 o0 v" f' r/ v! l! m% P6 B, v) i% D
    内循环试了4种方法,
    : O% E# J4 W7 R5 `; _1 b3 e  b6 h& V# i1. 直接调用 vector inner_product 247s
    $ w  e! [; ?( n2. vector 循环点乘累加 237s* P2 v' T$ H0 B' ]* }: Y; N( B
    3. float * 循环点乘累加 204s  Q/ R- Q! s  N, r0 c+ D4 {
    4. 空循环 100000 次 202s5 G' [# H* ^( y* O6 l7 C  D3 N

    / d0 _; F; p1 g4 u不做内循环 200s
    % H4 {7 E/ S" c# r, d. W9 q# I+ I& y9 r# D* W# J
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。2 d+ @. \2 ]2 y4 `
    另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    9 F, W" \6 d+ M. g
    4 N% n$ b2 f5 |2 [- \- d0 Z' M至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)) s2 A1 J# E' l7 O8 {8 r5 w
    6 q& C/ R8 x& r& X1 d+ @5 K
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    $ w2 S; S3 Z5 z1 w; k
    , Y6 v+ c: E8 ]  h% @
            std::vector < float > vec1(N);! y( x( X2 ~$ U1 t6 h" B1 O5 S
            std::vector < float > vec2(N);
    - |# \7 q, E3 s        float* b1 = new float[N];
    3 }3 F4 {, f5 A1 T        float* b2 = new float[N];
    1 x- t" F! C$ X$ g
    6 K6 S3 h/ [( E  Z9 O6 }0 |        for (int j = 0; j < 6000; j++)
    " l$ K" M5 E/ w6 }, A        {
    6 v) |% F$ I% G# n' x" T; s                std::generate(vec1.begin(), vec1.end(), []() {! }* U3 |/ u% A, e) M6 O
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ! {% D/ {- w  c- _3 ]' k                        });% @5 ^2 J- b3 r1 D3 w

    1 w' r$ G. M" y% T% E, O2 _                std::generate(vec2.begin(), vec2.end(), []() {  V( d8 Q! y6 M4 X4 N8 g
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    5 w8 X6 A" K: l5 h8 d                        });" ^4 m: C) N% V/ N) O) Q: u

    - M' f2 Y+ D. H6 Q: c  }                for (size_t jj = 0; jj < vec1.size(); jj++). ?6 X: g2 Q1 F  w- J* C
                    {6 n( K% O+ ^* ^+ ]3 O8 X5 i7 X
                            b1[jj] = vec1[jj];
    ; E0 S4 m" {% f                }$ D- S4 {2 f" J

    * f0 \) y4 p: ]" i) T# t% H                for (size_t jj = 0; jj < vec2.size(); jj++)
    / G* I1 T& g+ `9 E                {1 A3 Q8 m! C7 R- Q  n/ s
                            b2[jj] = vec2[jj];
      W( V+ Z  z1 m3 d. U                }! F( n0 s% ^2 i8 }( |2 r

    ) c0 A3 Q3 A' a1 r/ F. n) f2 C                //Method - 1  N=100000 247s  1 q6 f& c5 h1 e) J: ~0 N
                    //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);5 Q2 J  u* Z: V6 P& F* G! b0 o
                                    8 I8 t" t6 ~9 F8 M
                    //Method - 2  N=100000  237s8 c) y# c' g% F) T: T" G" l
                    /*( l; M' N! a! G% P% F6 |. `
                    for (int jj = 0; jj < N ; jj++)
    8 g0 s2 g6 ~- N, O& R. P& {                {2 M! ]5 Q( [7 C6 Y
                            fresult += vec1[jj] * vec2[jj];! ]  f; W, [7 G+ i4 _' ~
                    }8 A( \4 V& H; Z1 l% D" w
                    */
    9 ^( K, j5 P7 b6 W) ^                                
    , |; y3 w0 z* L0 U. E$ J; ?                //Method - 3  N=100000 204s
    $ ]: }- d, G. ~. Z. ~. Q1 e; M                /*  J" R# @; {+ Q" t9 H; l9 }/ W/ Q' l
                    for (int jj = 0; jj < N; jj++)
    ' q9 e! n' G/ o) I                {
    3 D0 K2 Y/ V9 \* B/ s                        fresult += b1[jj] * b2[jj];
    3 h" A9 w& h6 x4 b' d- F                }
      D: X, ~" t1 G9 b+ C2 i                */4 }" |, B$ A7 y- b6 [
    , q$ E5 K) W5 v/ x; H
                    //Method - 4   202s
    ' K1 k: X" u7 |9 o( f2 u1 a                /*- i( ]" J; b& K3 d
                    for (int jj = 0; jj < N; jj++)# U  d5 J& t+ s) ?
                    {9 G" [$ X* Z4 U; B7 A
                            2 w( W+ A- C2 q6 Y3 A5 h
                    }( u# v. D: W( W$ C% q3 [; C$ k
                    *// l: y2 x4 n- \; {1 D# p2 _0 a
                    //comment out all methods, N=100000  202s                , z1 H( `) P( Q
            }
    9 m2 p& j+ i$ T) H7 D
    7 Y1 o" x0 t5 ~; q  {! j& G        delete []b1;7 `( ?& e/ x4 B( D4 s8 I8 S
            delete []b2;
    - p' w2 r' c7 e: S8 ~# n
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?) m$ k+ k* W, @$ N
    6 L) g+ g* z; P& }$ ^/ ~
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    ! {' e5 ?' }. _+ Y" e1 |' x3 {
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:157 e5 E/ ]7 A: e. E- C
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    2 l9 W# \' e) M0 r( v9 `& Q; e. X( X2 t1 }2 a* u( I
    你第二个试验里面的j在循环里面又重新定义 ...

    $ V3 ^# O- l: x" E  |7 p0 H内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    ' L: }+ A0 Y- V! Y9 c( q8 H; }# `# ]3 b# z7 x  z4 X) \- L
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16
    : \( K9 U5 J' d% N$ H内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL% E2 g2 F. w' z

    % P& s) Q4 ^1 F. m% t. C不和它 ...
    ' y; _7 W# ?' q0 a4 e- [3 @5 c

    ; g$ v3 T; m% H0 C8 i  H不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。1 {. p- H" ^7 b
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54) ~& C2 ]' G) s- J
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)1 s! i6 @0 p$ y  k7 e
    {
    # R4 K8 i2 f, o4 U! x        comp temp, xtimesy;

    * H3 Z/ m$ R$ s1 V& }6 [1 ^这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。; L. F/ q* \0 [" A; w
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?: C. H! f" e4 V9 {0 @
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-4-27 12:25 , Processed in 0.044607 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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