设为首页收藏本站

爱吱声

用户名  找回密码
 注册
帖子
查看: 5664|回复: 25
打印 上一主题 下一主题

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

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

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?' z' g! w' ]& w7 L, [9 L

    2 [4 `8 ^" |* h& Y自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。  c. n- Y* o- L  l* y; m1 l
    / Q7 n0 u* ^) c) _" z6 b) \
    速度优化问题真的很有意思啊。
    : v$ @( m9 ?9 \8 Y
    " S7 {( f; A) w( r" z' X欢迎大家继续讨论

    评分

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

    查看全部评分

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    5 a9 N; z7 C, y6 i- U. j把代码贴上来看看?0 N7 T8 h9 T8 q: Q7 S! U* T/ N
    ' g, k+ S' o3 ~  k
    难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 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 编辑 & I1 X/ E. s0 b1 ~: O  y" ~( O6 o
    数值分析 发表于 2022-9-24 23:04- v7 b; ~  o& u- I& H
    拉下来?拉多少?0 `' R7 F( e7 b
    把代码贴上来看看?

    7 j, _/ j) P" {, M& @& A/ I4 f% P/ \
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)+ F. F3 D3 X! h' [. D( Z- r' h
    {4 J/ @- y7 C- S& I+ L* E
            comp temp, xtimesy;" l1 f- w& }0 x. `7 m
            xtimesy.re = 0;$ _8 _; H- W6 x9 e; ?
            xtimesy.im = 0;$ l5 d: A* f5 V6 V  Y& M% x
            int j0 = lenB - 1;+ G" y/ x4 B% v# Q$ t6 j
            int    i, j, i1, reali;% a* [5 z- z5 V& @7 g" Y* U. K
            if (lenA % 2 == 1)
    & q: |+ U3 H. U; K                reali = lenA + 1;2 B2 q4 [, P9 ?. B5 G1 q
            else+ b5 w1 k$ V3 G# a' F
                    reali = lenA;
    $ C3 n2 W: e% R        reali /= 2;
    ; w" b; t& ^$ R0 s8 L* t8 [2 R. ^1 \7 }
            int nconv = reali + lenB;
    # l7 b* Q; N; k, h% x  x& q6 x; k8 H        //#pragma omp parallel for
    7 y9 C: R) c( L7 i/ s9 u  ?        for (i = reali; i < nconv; i++)1 B" Z/ m* r; j' h( X1 G6 z
            {
    % B, F, K; ~/ n7 ?, B- Y                temp.re = 0;7 R* L: R' q, [- l; w7 U
                    temp.im = 0;
    3 R, Q+ h2 z: B& C                i1 = i;
    # r0 U/ O1 i5 x7 `                for (j = j0; j >= 0; j--)' ?$ ?) z1 c6 Y+ w) m# w4 m1 ?
                    {
    " j' D% W" }$ X7 I( b$ Y& Q                        /* floating date operation */
    7 y5 N1 Q! K( P) w& X: p                }

    7 }9 Y4 \; f" J# z$ L6 [  M        }9 I3 T# ~" T9 e5 _* W
    }* a6 O& t; e' y4 \

    " f" y4 c1 g+ M' D. Y9 ]xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
      b5 \: F7 Q4 E* I' h! E2 f
    2 ?* \; o' M: Y6 X3 _' A; S' p红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    4 U' v, Y9 x5 D0 d! J. ?" E7 j现在call xcorr 100次,耗时78s.- j6 `) m* d, h7 d$ Z; K

    9 F! a5 \: j3 w4 [, t如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    ' ^6 \+ W# f; B0 H' a! F1 K% q2 O4 U  T8 E' s
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33
    2 ?: h9 F: V- \) x$ z. p7 iMaybe Debug mode?
    / A. }* ~. G/ |7 A) g$ N" a& W
    2 s, P6 Q+ h2 g* {8 n
    不应该,看我上面的回复。6 i+ W. s( Q2 t1 s

    ' w- R3 ]' v5 a% J2 r8 j$ f我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    ; [  M% C" i8 {3 @# y- N- M( W
    雷达 发表于 2022-9-24 23:54
    7 Z$ x5 x" J- a: X4 r9 yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    1 D  f2 |. t0 R+ e- m5 [2 a5 |9 R# w# K{5 U: e* N! o$ n' y2 E4 |% ^7 r& B
            comp temp, xtimesy;
    5 G* |: p* n' E1 \8 j2 F9 U4 F
    + ~1 R2 G$ x$ }. t( G8 l5 w& F0 T- [
    这个不是这么比的吧。。。! f+ a% n! W# ?
    1 J: {; _  T% ?' w( r
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    + b" A: L3 l: T4 \
    8 N6 p6 z2 c* G3 ^* `* T2 t- 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 编辑
    " x1 p* d% k3 U7 `' E8 w" F
    数值分析 发表于 2022-9-25 00:206 i6 O- V" E* p
    这个不是这么比的吧。。。
    ( [. ~8 f3 {' y4 a. m* Z7 R' |5 d! X4 s4 E2 _+ ~
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    ( {7 Y# G. u  O; v) d. u

    % G; J6 C! K% B+ i9 \有道理。
    $ @- q% U% {9 L+ t3 |1 l所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    ( w$ d1 Z* s9 p
    5 q. d: x9 L' e1 ?* @0 w5 r5 P我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:46
    + f' u; v' W) P$ R- t1 @! o有道理。
    9 E7 \6 q' @- Q% c- K  E- I0 I) O所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    # u6 U8 l. V7 s你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多. ?  B% O! J% Z; b5 ]
    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, M9 c2 ~: t1 Y, Q" f$ f: E
    这个不是这么比的吧。。。
    # T+ M( A+ y2 F% J# T, |; P
    : L2 D5 L5 D0 g! K! j0 D* a您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个

    & u/ r5 z, L! S) v3 O6 U0 [* d+ a5 b% g
    现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑
    3 b- a! ^  [) A3 N/ j: N5 x
    沉宝 发表于 2022-9-25 01:48
    7 [: w. a7 P2 w$ D, w现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...

    / t! T6 H; ~5 j  n" d; m( V  s( m
    ( M0 Y& S9 l# Y! v是的,兄台说的对。
    ' Q, w" u( U( r% H& A8 y( u5 S2 i2 {. \+ Q$ ^  [
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
    4 l. Z+ T6 R0 x5 K: @, A- k
    # Z5 ^7 O. Y* A7 U雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。
    # K8 p- n' d/ u& p9 {0 Y: o6 `+ W" F( E' @' p6 `5 ], `5 V8 s5 `
    比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    3 c$ n3 c# e, k3 M( V/ J% U. i
    ( Y9 e& o9 D: F当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    - \6 ~: |3 K( s3 I0 H
    沉宝 发表于 2022-9-25 01:27
    5 h, C* ]4 \. L% [你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    4 V3 i9 A. k' |+ y' @  P

    * p* [7 h% p1 B% S又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。1 H' ]! D1 a2 T/ r3 \

    / g; |( Q+ Y( Z1 Y/ x我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47& ~8 `% W" u0 \& p, p3 ~3 n
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    , D, [% _- n! r! e* o% t2 x5 G! t
    时间差一倍的结果可以接受。) O& X5 K# L& |7 p, f- ~0 B

    0 Y9 C' L  D2 Y: `. l你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2025-7-18 08:55
  • 签到天数: 1934 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    ; A  v2 }, F- A1 B
    雷达 发表于 2022-9-25 04:47$ \* L) Z& N/ f3 D0 w9 O: ?/ x1 y
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    $ F3 X6 V; G* j; m' y
    8 u/ p0 I0 I% K+ i
    + `: r" B) a  M3 B! K2 c9 H: i6 ~

    # A+ i- h* j- o1 G# ]) z6 @5 y能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑 6 L9 w3 D* \6 s1 G. p, e" F
    数值分析 发表于 2022-9-25 14:58
    ( e1 B- d+ I2 C/ l能不能把这个也贴上来,看看和上一个有什么不同?

    ) [+ A: d* U- j  D- N理了理思路,重新做了一个测试。; ?2 B* b2 B( X; i
    做了两个 vector 和 两个 float *, 都长 1000004 p. U" d$ F0 @; g# _
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    + P" n% C* Z3 y* K+ r+ m) f- e, `- Y$ [8 w
    内循环试了4种方法,
    1 A* @( _. z1 f2 s1. 直接调用 vector inner_product 247s 6 \0 e3 h2 {5 d
    2. vector 循环点乘累加 237s: T5 K! y) {: y9 {
    3. float * 循环点乘累加 204s5 ?6 u- y/ a$ Y
    4. 空循环 100000 次 202s7 t' O+ e# N; s0 Z
    - L, ]! F  Z/ A+ L
    不做内循环 200s
    + M2 H; p: P& T; g: P3 p- ^
    8 K& P3 ]' [# Z; S; {( k你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    ' {$ P" U* B& s! ^另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。9 S# b" k! S# N, ?7 T9 L# B
    % c) g) J% Q, e3 f' v' N$ b
    至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)! s' q% y: I/ M

    . N, a0 u6 a" b# ~( d2 V+ @(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)
    7 Z$ N2 L* E, \; b+ `* v
    1 h8 e; i1 W3 v9 c% q4 M2 I
            std::vector < float > vec1(N);
    # I; s3 V. v: J4 W* a1 A        std::vector < float > vec2(N);
    0 b3 F0 l2 c* W* G# W        float* b1 = new float[N];5 J: I! m! ]8 N# u: h0 a$ S
            float* b2 = new float[N];
    - w, ~0 P$ p3 R* ~& A- k+ G
    2 ?0 x2 S) C1 s7 M# I        for (int j = 0; j < 6000; j++)+ @5 Y  E6 T# a$ y9 M
            {+ l  \+ j" V8 I  u; f
                    std::generate(vec1.begin(), vec1.end(), []() {
    $ F4 L( R/ o( p. F* R# Z- a                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    & X# R$ Y$ L) a3 L( m                        });
    . v3 N8 q- N( k
    4 }5 x6 |) D* n- J                std::generate(vec2.begin(), vec2.end(), []() {
    5 S' _, h& p- P" R4 a                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    ! H4 R; Y$ u+ V/ u, T8 T9 f                        });. |5 ~, w) p9 ^+ H6 z  Q* ~, f

    8 I, b1 S. M4 e9 z+ M                for (size_t jj = 0; jj < vec1.size(); jj++)
    , e% G0 h# A' Q! K                {
    2 @8 q! R* J9 X4 M                        b1[jj] = vec1[jj];3 m, B4 m0 g( C7 k1 w6 z1 x
                    }
    3 N3 b4 N( b2 p* J) ?+ u% j8 W, A" c5 B/ U7 R% l# p9 t7 y! N$ i
                    for (size_t jj = 0; jj < vec2.size(); jj++)
    2 x" H% R9 ^6 {( M                {- J! a; e$ C  A4 J* s5 {* X
                            b2[jj] = vec2[jj];
    ; N3 x* S& m- T2 E: K                }) N7 q9 c/ v3 y( Q9 V+ r
    7 U- w/ I; L0 c8 c; }* p
                    //Method - 1  N=100000 247s  
    ! X: ~7 m* G9 Z7 L                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);1 c& V1 X' P. W+ R5 o# e
                                    
    9 L5 Q' ^) F( M- L2 q                //Method - 2  N=100000  237s3 j2 z0 ~& o# Q8 _
                    /*
    % B2 Z+ J. S' k+ `- {4 t                for (int jj = 0; jj < N ; jj++)
    3 d' g4 X& Z( V0 P# V5 M                {0 D; f  n+ m% K( Y- I
                            fresult += vec1[jj] * vec2[jj];
    * y- _  s/ e8 J' {                }! ^/ @5 F. O% D
                    */4 L. e, M6 Z5 F
                                    
    % L4 u8 F3 X: k& p) F2 |# Z: o                //Method - 3  N=100000 204s
    ( Z5 C9 ?9 [# ~6 g0 {/ c                /*: M  T9 ^' O# z; L
                    for (int jj = 0; jj < N; jj++)
    / [5 g2 f9 J' G, w                {/ M2 c% `0 K  w8 @8 p1 q
                            fresult += b1[jj] * b2[jj];  {+ Q' U2 k$ R% i& e- c; o
                    }; {4 h4 ^9 z0 y% A0 T7 D% d/ Y
                    */- u7 J! |5 T& F+ l$ K/ B
    % \4 U3 I5 n: a: K" K, ^
                    //Method - 4   202s
    : g4 @: E: Y! P" U  A0 [                /*
    0 }) D. D4 e: S7 |* ^# z" N0 G                for (int jj = 0; jj < N; jj++)
    ( u) k/ L  c% l7 L                {- t1 T& ^5 ?! w2 v) f3 z0 Y3 x
                            , @& e6 H7 K3 h9 M5 c
                    }, c# g8 g$ V  c* u/ @
                    */
    9 C7 Z) }: m9 Q0 ?0 `! C( E                //comment out all methods, N=100000  202s                9 ^7 E) A) K+ f( ?8 d
            }  s; k3 n% C$ u& n/ ^

    , P! V- b& K) d& m! m& }, r- w  J4 @        delete []b1;" T3 f; H$ _$ u6 M4 v8 F
            delete []b2;
      [: K0 o6 K! L- G
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?. z  \+ g+ y$ l, p' e
    ! d6 O% H& d' y8 v1 n" V# h+ y
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?2 d" `- {8 t6 I& |+ H, @
    回复 支持 反对

    使用道具 举报

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

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:15
    9 P) D- {# B  D9 e" d0 p' p3 C瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?. `0 A( r6 S. Y; @$ Z  g5 z, e1 d
    0 `( n1 @1 p2 g) M# v; X/ @0 Y2 l
    你第二个试验里面的j在循环里面又重新定义 ...

    8 ]# ]2 A+ b8 z6 g0 f$ ~9 P内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
      j2 W$ `* g7 S
    + O3 O! `( b! Y5 w6 ^% T. m+ S# g不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

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

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16, ]% U/ ^' p4 W. C: h! r9 W$ x
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    , x5 @- |$ U4 O+ {
    9 I+ k: @) u5 I不和它 ...

    2 H; R1 W, {3 s; [2 ~9 M, l
    ! E; J: s  N& e/ v7 F& D不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。; K* k, [& E  e6 F1 T! V
    后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

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

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54- W+ g2 a$ y3 r* B
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    " l3 L) r  v) y7 m- O- h{6 n! i& z8 Q, ~0 `* k
            comp temp, xtimesy;

    . x6 }2 ]9 Y: X- x8 R& y+ c* J这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    9 C, \+ p. A6 C5 l+ v' C内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?
    1 v/ n3 W) e, Y( f$ ?7 FVS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

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

    GMT+8, 2025-7-26 00:09 , Processed in 0.042865 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

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