设为首页收藏本站

爱吱声

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

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?* v5 {* l7 v* l: t4 f

    & V5 T$ A% q5 E  k6 V7 i7 z自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。! B% N) ?* J0 O" [' @
    " L" g) n) ~) R" I5 m
    速度优化问题真的很有意思啊。" I$ }9 W" W. l

      h& W( Y, f- P5 c, y' c2 B5 B欢迎大家继续讨论

    评分

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

    查看全部评分

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

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    3 D. [6 n7 l; f- w3 P, C把代码贴上来看看?0 F5 t4 e! \2 V8 C6 Q% p
    ) I' S* ?7 \' j1 B( A+ c' s# l
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑
    : a& q: \6 B; T3 c
    数值分析 发表于 2022-9-24 23:04% P! c3 W3 t! y0 w
    拉下来?拉多少?
    & v" Z" q2 M9 P! E2 U$ }把代码贴上来看看?

    3 R0 ?8 n# Q4 [; o" v/ q) l) Z& S! D& V
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    3 c8 \) q5 ~' S0 o+ b  L! b{
    4 J! O, o3 H4 o6 s        comp temp, xtimesy;
    5 v4 Z3 a: [0 k, f7 P        xtimesy.re = 0;
    5 q' j( n& b. J9 Z2 p, O3 f1 g/ @$ J        xtimesy.im = 0;
    7 W! ~4 d& J' V8 O5 G, [        int j0 = lenB - 1;# v$ o: f5 q! k/ q( n1 q. Z
            int    i, j, i1, reali;
    " R6 c- ~2 J) Y" m- X! ?4 C# w        if (lenA % 2 == 1). H- I* S7 [4 y7 l9 O: B! S
                    reali = lenA + 1;& t8 m2 [1 y* k! R7 X# _
            else
    3 E$ R9 p. J2 i: r! A" ^                reali = lenA;# j7 k5 t& V1 \, S3 n
            reali /= 2;
    , i( |( k+ b4 Q, l3 Y' z$ U: D; f6 P0 n5 F$ t
            int nconv = reali + lenB;0 ^5 s9 C' G! h$ n- |
            //#pragma omp parallel for
    # }. w  j2 i, A3 G        for (i = reali; i < nconv; i++)
    9 F. @) z+ _% a        {! Y. A$ x; v' y% u0 k) n# z
                    temp.re = 0;6 u, `6 g+ \7 @* V" @) `5 |% l
                    temp.im = 0;3 o+ J* c5 j' B
                    i1 = i;( w- r5 G9 H3 ^: E
                    for (j = j0; j >= 0; j--)( a1 [# A  Y. k' b' A
                    {1 `4 O3 f0 J( Y. R9 g6 ~- P
                            /* floating date operation */
    * _& r# `" n% M) b( d4 ^                }
    # a$ x, x. ^3 C0 `/ M6 j
            }
    2 v: j+ L! Z- ~% y}
    ; K; ?) s8 v* S+ r! @- u$ o# i  L1 Y1 C9 }! q
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样5 O" ^+ I# r) ?
    % ?; K; d, p/ R% u" ]+ [! x
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    1 x; [; ?9 ?5 s' z现在call xcorr 100次,耗时78s.) }! A& \4 Y+ e3 R0 e
    ; ^4 O) S8 \0 l  B$ v1 Z. K4 M1 U
    如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    2 h9 E$ c, M4 }' ~( _9 R/ Z: P
    ) o  C0 a$ y" N; b3 Q' D9 D
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:339 v. \3 e+ q+ R5 ^: n1 |: L
    Maybe Debug mode?

    / N" e0 C* k6 |& b0 a6 g
    2 v9 L) r$ b8 c2 U) v不应该,看我上面的回复。7 g) ]: L& k! }$ U: \

    - a) K: [/ H8 Y8 N  I7 t0 s我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑 + S2 p1 {- q* B9 y6 S8 Z. n
    雷达 发表于 2022-9-24 23:54
      B- W- {0 R2 Q) K7 W, E6 rvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    0 m; N" \( ~/ I# R" v6 W{1 k# M1 y/ P' a' `) E8 R: E
            comp temp, xtimesy;
    7 g  Z' R( ^2 U, B; ?7 Z

    # |0 i+ D8 c- m' t5 x$ h这个不是这么比的吧。。。7 m0 I) J. X6 f9 J0 D: R4 x

    ! ?+ T. h0 ^& i2 d9 Q4 Z/ M$ O您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    , w  K0 T" o& ~/ N( x! i. S% G$ w. L; b9 ^! a5 d2 k
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    , `1 [* M6 P0 _, m" I, L! H8 p
    数值分析 发表于 2022-9-25 00:20+ \# Q! X* \3 _( r0 J9 ?" L, ~
    这个不是这么比的吧。。。
    5 Q& o2 E0 t! l2 ?" e; f+ r5 A% O/ _
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。

    4 N" G* {' }7 r1 Y4 {2 F+ {# r) r( x
    有道理。  F. W- @: e( W3 [+ ^
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    . [9 A% I" Q; p! u& F. P5 l7 R. Y  V7 h& W& v7 C4 {. g
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    ( x' e& ]2 Q1 c有道理。
    8 ]0 Z4 t1 R2 V( ?3 f( z! ~所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    0 o9 m) j! d/ l$ F
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    8 |1 J3 |6 R  t0 lWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
    * ?5 N  J% v/ o: F这个不是这么比的吧。。。
    - T3 O: }5 U, ~7 R7 u: p, ^4 Y9 \% f- M0 t$ D7 C3 m* r; \+ D2 t
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    1 f# ~# B/ q) a- U) r* _, O# M3 F- r# g- ~$ ?
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    1 _- u" O7 d& K* e6 y
    沉宝 发表于 2022-9-25 01:48
    9 m/ h" s% d0 I# c现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    $ s; }7 ^' M5 o# k" p, Z

    6 x5 s) Z+ X* A- P6 d是的,兄台说的对。
    % [- x8 r5 `' i4 l0 h  E
    - T, N+ ?6 z3 `, {$ q其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。: N; |  O. t! l8 G. Z/ x
    ' H" D0 {9 F8 Q% [& C
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    1 `- i: d8 I  A! L7 @6 d$ K/ J5 N: e) R$ {. L
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。; Z1 |9 G6 G5 A: u& c" d
    * E1 [5 L+ e/ [6 o4 z
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    - }% f$ A5 Q6 Y8 U
    沉宝 发表于 2022-9-25 01:27
    5 R& D0 R# ^; L, Z5 T" \你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    8 h3 C3 A, M) d- w; x

    7 q: R: R% w  n% l# N: l又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    3 a0 c5 l2 _6 G; v
    7 D5 a& @# e* o3 l' Y' g2 }% S我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47% i0 ^3 i2 W4 A: z: X2 M& o
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    * {# ]) w& b/ t0 U$ n# a
    时间差一倍的结果可以接受。
    7 R, \5 @/ G+ k: O6 o7 [6 J
    & \# c, H: k  P你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

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

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑 1 q. u( e% g$ y5 `, e7 w  f
    雷达 发表于 2022-9-25 04:47' ]% F) W7 |/ X) f3 ^7 I
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    / o, n7 Q" D6 U( G. f& Z% c& a5 y7 ]' d  c& T
    + R3 G2 l3 ~# c2 g" r
    / P/ R7 X. ?8 K
    能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    1 U0 i* F0 E# _) E+ ]+ ?; Y
    数值分析 发表于 2022-9-25 14:58  ]: W- l; n$ g& \) l0 d4 I( @
    能不能把这个也贴上来,看看和上一个有什么不同?
    ! q$ R- f/ {. q; T  v' q$ Z
    理了理思路,重新做了一个测试。: y! d1 C  F3 V* F" ]; m' d' j
    做了两个 vector 和 两个 float *, 都长 1000004 e3 T$ b2 R% G, c5 _/ F+ C- P
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.4 Y$ q) v. |: L" l- }9 b

    8 H, M5 v3 d0 c' [" Q; U2 l) d. |内循环试了4种方法,
    . U8 x4 v( e6 [# k1. 直接调用 vector inner_product 247s $ s! U3 z; l9 z. x- a" J
    2. vector 循环点乘累加 237s
    ( |$ r- d( z' z. l1 p3. float * 循环点乘累加 204s
    1 l$ U3 W6 R& a. B% ^4. 空循环 100000 次 202s
    ( c6 g7 h9 ^# r! Y
    ' T6 d7 Z% K* d% S不做内循环 200s
    - ^$ I# z! [/ F- D6 k+ o) F
    % A2 d" C: S" E8 E8 i你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    ( i+ p: a7 A$ A# f; Y. ~另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。3 g) |7 w$ P4 k8 Q" e: g! j

    7 s! e  R8 g- N1 S) z至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)$ o4 t0 ]0 ~- n' D

    ; s, ~0 ?" z) p% k: M9 W(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)$ C1 T7 b$ Y" s# Z
    " |* \; {8 R) r5 N" o
            std::vector < float > vec1(N);& O1 K* j9 T) D( a# C6 P  S/ }; V
            std::vector < float > vec2(N);, s8 E! m5 j1 T# S: ^( s5 v
            float* b1 = new float[N];8 g) z4 }" F9 m, c  ], G
            float* b2 = new float[N];4 ], h9 H( \6 B$ t

    3 Y+ @( j; d( k$ B# u- G  `- q        for (int j = 0; j < 6000; j++). \- J# |/ N+ b9 u& ]  g
            {
    # L3 F% x8 R! p9 T: R7 l' r( c                std::generate(vec1.begin(), vec1.end(), []() {# H% }4 j9 f1 x* U1 ?! \
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    ; e7 d) `! {' W1 @% ~- F                        });
    - ^- L7 O. B2 V% c4 l3 d2 B# p
                    std::generate(vec2.begin(), vec2.end(), []() {8 y1 I7 U5 K$ H0 |. P# r6 o" l3 \7 r! }
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;# i  t0 z6 \1 \" f! W/ _9 F
                            });5 Y1 H. X+ ]; l( K9 j) h+ l  b0 N: Q

    9 ~3 M$ e# o$ ^- F# P                for (size_t jj = 0; jj < vec1.size(); jj++)
    2 U! `0 r/ i5 N3 q; ^                {( I% }& s6 x: j8 m+ g0 N
                            b1[jj] = vec1[jj];- `: h& [- k8 }% |5 D
                    }
    7 Y- K) \$ t$ s* y! [; i
      h0 W( V/ M$ t7 \+ I* u8 {                for (size_t jj = 0; jj < vec2.size(); jj++)7 P8 {* H, d4 N. t+ r+ z
                    {
    9 d4 j: r. V  i# s7 B3 I3 K                        b2[jj] = vec2[jj];% l% b# V( c! A
                    }
    - n; p. i$ s0 l" b7 E( q. L8 j( r& _3 r) T
                    //Method - 1  N=100000 247s  
    # B+ ^% J# v! `" O% `7 p' I0 z                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    7 u+ l1 o1 ~( B& \  v6 B                                
    , p! }  H6 R( H' H* d! W                //Method - 2  N=100000  237s+ d( t# F1 r5 l" n' B& ?
                    /*# x, t9 E5 r$ K9 c4 I
                    for (int jj = 0; jj < N ; jj++)
    0 a, i! I. z6 r  m" b* S                {
    7 L" A5 x! J( v# I. g                        fresult += vec1[jj] * vec2[jj];
    1 N: [  C6 j8 w7 `% a* g3 p! K                }4 A+ s$ O' _# f! U# B8 p  }  b3 A. M
                    */
    7 v4 T" ?0 j' R, i                                  u: r" [" |  l8 \
                    //Method - 3  N=100000 204s# ^  q: h3 _  \6 ^
                    /*3 x/ T& t. C# T1 s
                    for (int jj = 0; jj < N; jj++)
    8 i& n, d" v. o0 C7 @4 {4 X                {# l  Q6 g9 H8 M" q- g. G( x
                            fresult += b1[jj] * b2[jj];9 Q7 N1 {% e# W6 R+ A" w8 M* z
                    }$ `! x" ?/ [" @
                    */, P0 M/ {& X4 Y& r1 {

    ! z0 a0 o# d) B2 l                //Method - 4   202s
    . Y5 Z& n  S  m* w) n. Z# H                /*
    3 Z6 r, x  P- F! H* c                for (int jj = 0; jj < N; jj++)
    ( g( U- W5 ?" f  K                {
    6 K. F- B$ o6 q! w$ s# ]                        8 O, R  I  x: Q0 e7 m0 z" g
                    }7 }6 I1 O1 \  C; L" ^9 N
                    */6 G4 f  ]6 u5 I0 H6 N! N% N
                    //comment out all methods, N=100000  202s               
    1 S  f. N. ]0 {$ h' J1 x% a' x; c- |        }
    0 d4 ^6 s4 O( b* ^5 }0 E2 T
    $ C2 q; w% e& L+ x        delete []b1;7 C: y0 d# J* ~; J- ?$ ?
            delete []b2;
    $ Y6 _# ?; z. |7 J2 G, f+ h7 q
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    # T% K+ G5 D  i! w7 O& m: g. j
    5 \! K$ _9 y1 r7 q: Y你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?1 z5 f9 r5 @, f  `- z+ A
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    ! j4 }5 v+ @0 \, `! Y8 O% p瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    ( ^- A, u& j; c/ W; v/ H7 u; b  Z5 ~5 V2 |) Z5 U5 B8 e$ j8 f
    你第二个试验里面的j在循环里面又重新定义 ...
    ! ^$ C% z3 \; o$ F; t/ ]8 y  a' {+ `
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL9 a/ }% A5 {  G" K  i$ A2 ~
    ) Q" M2 e0 ]% y3 O' g
    不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16# a% Q% R; U# p' R6 i
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    9 Y7 p. C, u! ?( N1 N% `" |* W0 @% }) V3 \
    不和它 ...
    ) ?5 H' h: O8 M

    5 H- B& i, H9 p  C( K8 X不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    7 \. @- i3 e9 B; {) k" q后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    7 I" ~' B! u5 W, mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)6 D, a8 q9 R% r. J
    {9 o6 @+ |  h  q+ F+ O
            comp temp, xtimesy;

    1 R* J( _0 _7 C- c. ]这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    : c& s8 k3 L! S* ]7 ^$ t+ I内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    ( N* i  }8 j2 {$ v) vVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

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

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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