设为首页收藏本站

爱吱声

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

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

[复制链接]
  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?# w2 V0 B$ L4 l1 I

    ( Z9 Q7 L, I6 F4 o8 F: ]自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。+ [4 J! \3 e4 ?& k
    ; U8 E0 Z: ~5 {3 ?) L! i
    速度优化问题真的很有意思啊。
    9 f- b$ e% e6 K8 z! M) P) l8 R- f7 }' \) D- k
    欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    6 n9 o! H: I% E把代码贴上来看看?
    8 n( }# x& c4 u& y% ^1 n1 D* D' r$ A7 p  B: H1 q2 M/ o
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 2022-9-24 23:15:41 | 只看该作者
    会不会代码本身的缺陷阻止了自动优化?另外,硬件配置和开发环境可能也有关系。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-24 07:04
  • 签到天数: 126 天

    [LV.7]分神

    地板
    发表于 2022-9-24 23:33:02 | 只看该作者
    Maybe Debug mode?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    0 R0 \0 `. h! c$ P( p4 f
    数值分析 发表于 2022-9-24 23:04- f  W4 N, t2 s6 t; H- V
    拉下来?拉多少?/ `3 d" U" T; A" m0 D, F
    把代码贴上来看看?

    ) Y2 b$ ?$ B. ^4 j/ d, S* P7 c8 r, p$ Y( D% c
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)$ E, ]+ o/ Q" R6 l7 ?2 @. \4 G
    {
    - O1 o) i2 E) f. j        comp temp, xtimesy;
    2 }7 `. |2 V) D4 Y; w        xtimesy.re = 0;
    0 X% E9 J9 y# n) K        xtimesy.im = 0;* H' T0 r* y' W4 d" G
            int j0 = lenB - 1;3 J! `  V2 N) S/ _4 I
            int    i, j, i1, reali;
    2 e0 w: N8 m: h' J8 c        if (lenA % 2 == 1)
    2 o: H* K. \$ a( V                reali = lenA + 1;
    6 X0 Q( V" j& Y; y/ i        else
    4 k- m4 ]* G0 z2 ~/ O- L: u                reali = lenA;
    0 d1 Q" T$ v2 r        reali /= 2;: \  N6 T# j5 ~/ T+ E
    ! v+ _( ?$ a( A
            int nconv = reali + lenB;  S& T/ T/ l) _
            //#pragma omp parallel for" h' ^5 M2 h/ H
            for (i = reali; i < nconv; i++); r, V; }7 O" G9 o# p) ^
            {& |$ V1 d/ d" h/ |
                    temp.re = 0;
    1 A4 F8 }! a* N5 x' R# d; _                temp.im = 0;
    4 _6 X' K6 Y" m( h- z- @                i1 = i;
    # ~! d- d0 t; w+ O: k                for (j = j0; j >= 0; j--)
    8 ^  a+ b) L! F8 q0 z, d                {
    " n6 C% L& x2 e) R7 Q, V# P- L                        /* floating date operation */' Y$ U" ]1 I' V/ N$ h6 d
                    }
    ' D3 p8 o' w" T0 T
            }( D$ [8 u" O8 O1 r0 Z" ?3 u! V
    }
    " e1 [1 r# C) ?/ t3 G" h
    4 I$ M! t3 A! Rxcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    % v; J. t1 a5 g0 Y9 A. h  E0 q. |: K8 T
    红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    5 F! H8 S  N$ e8 G' O1 T- M* E现在call xcorr 100次,耗时78s./ n* |. V% n7 ^8 x* g

    2 h3 S2 A+ n. T+ h) L如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    % J2 E6 ~  ^5 U3 q$ S3 h" k( {
    $ ]6 Y& b( J" I4 K- b# d! Z
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33, i4 S+ a" |! t$ ?8 k. W, t
    Maybe Debug mode?

    8 d- c! Z1 B' g5 P  s. T) s9 `6 {2 C& W3 ^+ _7 m/ Q# H- {1 Y8 Q; H
    不应该,看我上面的回复。
    6 R2 a9 d2 f4 G
    0 s$ s' v- V6 ?5 ~6 x. C$ ]我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    ' ?( q9 F  Z# d& w) V: o
    雷达 发表于 2022-9-24 23:545 J: k% J* Y+ ~% s) B$ W" |
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    7 J9 [, @, k+ J$ ?, w{( D8 H3 Y+ P! l2 A; d, T
            comp temp, xtimesy;
    7 ~- ]9 Y* K3 C% U( q

    " Q( k3 c& r/ R9 M这个不是这么比的吧。。。: S, e7 ^, ]6 k8 e( w4 h( y
    & ^- t: f, n' @
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    & P/ P' f1 Z5 Z* h! c5 p  E- Z9 s2 [# H' u1 A
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑
    0 C* a% o, ~- @# x9 B
    数值分析 发表于 2022-9-25 00:20
    3 L& ?; F. n' R: @* j/ h5 Z- `这个不是这么比的吧。。。0 P% E+ `* y' X8 Y
    ; s) p+ j$ V" d; C( e2 F
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    , A" H. p; b& I
    # m# T3 e5 I/ J3 u
    有道理。
    $ ^( U9 l+ U% U所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。, h. }- r8 L! n7 f+ Z
    4 L3 G0 l2 g, _, H
    我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    9 s6 v  V* B& B* J4 U5 }有道理。# x2 j2 p5 a- F& f8 r" Q- N) y
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...
    & {, k: d: v! |
    你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多
    * M/ M+ \9 f& k: s, V6 ?' [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
    0 t: O. h- Y" w这个不是这么比的吧。。。& @: Z/ {3 l/ s7 I) p) v
    . b) J& k9 q7 \/ L0 k/ o
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    + y% c0 I0 O2 D, S, B' _2 I9 p* T' r2 c- @1 d
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    + z" }! u% L, L( P& Y+ Q0 j
    沉宝 发表于 2022-9-25 01:48
    : m0 Z8 P  g+ ^4 k$ N/ A' o现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    ! T4 h2 W9 w* Q! ~0 C

    1 V" F0 W  z" |/ t/ |3 Z' p3 V8 W是的,兄台说的对。
    * `3 `, v& Y. h+ t4 d
      x( b, V& D. W3 U& Y' E+ L其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    8 s) k6 l2 t" [2 O0 `0 ?1 N* c+ s, q! E. G; M) t$ M, @% o
    雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。. q5 N5 A  c- S/ a" |1 z
    " V2 u  w" @! a
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。/ w5 C: u+ K/ p8 v. @  G

    ' ^: J3 {+ O! E/ j6 ~: C当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    # x6 L+ I% ]4 r  V( k+ S+ T
    沉宝 发表于 2022-9-25 01:27
      Y0 |1 U8 s) B; l6 R0 P: N你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...

    6 K7 @- I$ Y- F+ s: M, G+ O& x. o
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    $ T! [( P5 x9 u( k, _, {- j3 y$ F' l4 `% J. O
    我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:479 _0 N% z( O: K- ]+ [, P4 w1 y
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    ) b* u3 h* V7 j) x
    时间差一倍的结果可以接受。: H$ r4 W9 C) Z" X  [: a* R; o

    & q. P, U& A( @你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2026-2-7 02:13
  • 签到天数: 1955 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑   Y* a: A+ z0 K* r2 U+ v, [' q
    雷达 发表于 2022-9-25 04:47! u. @7 v% `. s) v* o
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    9 R: n& c  s; U! ?( v
    ! Q# u) j- Z2 E; u- ?. P

    & v2 ~/ r+ x0 I0 m9 P5 S
    2 F" ^) z: n$ }2 D& i8 b能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 3 y8 v1 K4 X( j1 B) p
    数值分析 发表于 2022-9-25 14:58
    1 g! |0 u. t; ~+ e能不能把这个也贴上来,看看和上一个有什么不同?

    - e7 y) d- V; Y理了理思路,重新做了一个测试。
    * _& g( |% y* A. {0 N5 B做了两个 vector 和 两个 float *, 都长 100000" B" Q+ t7 j2 G, |  s
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.+ o0 S2 R+ g$ W* @1 Z' k
    9 T: I7 f! v% E. [. `) Z2 T9 I
    内循环试了4种方法,* U7 I/ L( A5 J* Z
    1. 直接调用 vector inner_product 247s 1 b$ Q( o& p. x$ m& v/ b$ w' k
    2. vector 循环点乘累加 237s4 F; U# Q% ~9 @0 Z
    3. float * 循环点乘累加 204s
    ( D$ W# z1 s" p! T# R7 u& g4. 空循环 100000 次 202s0 M) |0 K+ t+ |
    3 _9 q) z3 W  u
    不做内循环 200s
    ' S  p* r. ]# H2 U. V, i+ }  y# F2 o9 E! E* G7 X3 `  L' _
    你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    8 l8 A- `  L0 z另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。/ B; E9 z& E1 Q! o% z

    , c3 A( F& e; p: T4 }! t$ l至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试): Y% s& Z2 m, C3 a3 I' r8 q
    # i6 M0 X3 t/ L% c7 G
    (为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)9 y2 x9 y. j3 M1 F0 r# |/ l

    % V2 w' l  R; P% o" f' z! \) g1 `7 t
            std::vector < float > vec1(N);' Z0 ^# K: v" q2 |) |$ M  O
            std::vector < float > vec2(N);# d' n2 \8 G' l2 M' v1 E7 K& y6 K+ z
            float* b1 = new float[N];) k6 ?9 y4 w# o! B* \( f/ Y7 p
            float* b2 = new float[N];
    , O  Z( I/ I( r; D! _' @+ a, _- p% U; R9 b6 J$ v
            for (int j = 0; j < 6000; j++)3 D& l$ ?! E4 ~( {0 |- M
            {; S- p+ v2 ?* l
                    std::generate(vec1.begin(), vec1.end(), []() {
    $ z6 z  @- J% C8 S& q7 z1 T                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;; {# E' [4 {0 f0 \9 |
                            });
    / g# f$ T1 J; L
    1 s  g" i; r6 k/ P( d8 U                std::generate(vec2.begin(), vec2.end(), []() {+ k1 F' k/ d$ {0 ~6 V# ?% q1 C) U
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;8 W$ m, ?7 ^9 t0 d
                            });$ U! \! I. e  V2 Q( L
    2 Y1 M5 p! {/ `& v8 {! F
                    for (size_t jj = 0; jj < vec1.size(); jj++)+ j) D$ n4 W' S& U5 X
                    {. N5 t: t, W% K+ f
                            b1[jj] = vec1[jj];; E* c$ `2 {2 Y) b2 W# s
                    }
    $ l. Y2 r& D: {( s1 [% ]! l4 D: k& F' q% Y! {' V4 {
                    for (size_t jj = 0; jj < vec2.size(); jj++)1 l+ H& ~. ]+ A" Y
                    {; q1 v, s. A3 \0 v" X
                            b2[jj] = vec2[jj];! E7 @& W. f( S3 o8 J2 f6 f/ x, f
                    }
      J: C2 t' V# a$ e8 P( c: p' W4 }# {5 y, V0 A
                    //Method - 1  N=100000 247s  
    8 c; \) B! b' _( t0 q0 @" _4 [                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
    : z2 Z( @4 {4 x  r9 q/ i9 {                                ) f( g. @% [' o: E
                    //Method - 2  N=100000  237s& A+ s& R. s0 m! a: a
                    /*0 U( Y0 R4 x) l# L
                    for (int jj = 0; jj < N ; jj++)
    & ~7 ^7 V) t* m0 I' w& t  F( F/ U+ l                {' i0 |# h1 z; e' u3 l2 ]
                            fresult += vec1[jj] * vec2[jj];0 y- l* q) Y! Y/ H( D+ ]! g! A
                    }  \1 O2 \) u1 `6 Y3 s' ~
                    */5 o( S7 G7 q# r- H
                                    # g' q2 b" B* Q  {. P/ U& t3 ~
                    //Method - 3  N=100000 204s
    6 K' n8 a3 M) k/ B  e* K                /*
    , W; ~; G1 X! s  r+ D                for (int jj = 0; jj < N; jj++)
    # H$ E1 ?# l, c4 i                {& P" S" l% @+ w6 t" X4 Y. J8 P$ X5 i' B
                            fresult += b1[jj] * b2[jj];2 ]# f* S# E# U* f) H, g
                    }/ t* K6 s( I4 N
                    */% Y% x, q# r7 A" z! d; F6 v7 Z

    ! c9 r; z1 X6 n- K' n& _) A2 n2 E/ v                //Method - 4   202s
    # o7 k1 b- N1 M                /*
    : K* B$ v" e$ ?4 y& a2 B3 A                for (int jj = 0; jj < N; jj++)
    ) X  b; ]1 b3 |3 C$ S8 I                {
    7 m6 ~( f5 E& [' q& _! d2 p/ [                        * h1 L! G) ^/ ?' m; K% y: K
                    }; w' Z3 D  C8 [$ i/ B" n& @
                    */
    ; _  T7 q  s4 k5 |7 [                //comment out all methods, N=100000  202s                % V$ R; L% e4 z2 G& ~
            }
    7 i/ R0 K! C# X% E9 q! s0 q
    2 F. ]& G, ?2 G/ y- y6 I6 v+ i        delete []b1;* J& f" v& [) p% V+ j$ b  J8 v
            delete []b2;
    0 {+ C$ Z+ A# A1 ?% ~. a5 g
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?7 X# }- c# C- ]  i5 n: W
    9 d  S( b5 ^" K9 c; F
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    - J) m6 A1 E4 P! I- o
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-9-22 22:19
  • 签到天数: 1183 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    0 Q% V1 t  M2 |8 f瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?' g! g/ x! g( j" [% f' {. A3 e

    . E$ w& O6 T0 T5 q) a你第二个试验里面的j在循环里面又重新定义 ...
    5 ~& @0 F$ U6 c
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL1 K4 o  m' `0 A- R

    4 o7 q& K6 T& n; u4 \* {不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16& U5 J) C& \: a! o
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    1 D! B; M) ]7 c0 R* X3 m
    ( K" Z6 D% q. d$ K* T' y; R7 |不和它 ...
    $ h! s  S& `3 W/ ], S& i6 ]+ A# y

    2 F' {3 l6 }& c/ D不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。( W9 G, E- _3 ], k4 i, O
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:547 b" w. ?  d8 R! z
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
      d3 q2 j: j" o' m- l' ]{
    % ]  E! G( F9 Q        comp temp, xtimesy;
    ( f+ {  w6 G# T4 N- z* X! s$ r2 \5 |
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。& |2 }) b, d5 k9 I0 n- d3 W$ _
    内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?+ N$ r& M, }/ n$ R$ q2 {- {
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2026-3-7 16:17 , Processed in 0.067000 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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