程序性能的初步优化与分析（以 C++ 为例）

最新推荐文章于 2022-03-01 21:58:56 发布
最新推荐文章于 2022-03-01 21:58:56 发布
阅读量222 收藏
点赞数
分类专栏： C#语言 工具

去年圣诞节浏览了 Milo Yip 的文章“如何用 C 语言画一棵圣诞树” 后，对这个圣诞树生成算法很感兴趣：

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#define PI 3.14159265359

float sx, sy;

float sdCircle(float px, float py, float r) {
    float dx = px - sx, dy = py - sy;
    return sqrtf(dx * dx + dy * dy) - r;
}

float opUnion(float d1, float d2) {
    return d1 < d2 ? d1 : d2;
}

#define T px + scale * r * cosf(theta), py + scale * r * sin(theta)

float f(float px, float py, float theta, float scale, int n) {
    float d = 0.0f;
    for (float r = 0.0f; r < 0.8f; r += 0.02f)
        d = opUnion(d, sdCircle(T, 0.05f * scale * (0.95f - r)));

    if (n > 0)
        for (int t = -1; t <= 1; t += 2) {
            float tt = theta + t * 1.8f;
            float ss = scale * 0.9f;
            for (float r = 0.2f; r < 0.8f; r += 0.1f) {
                d = opUnion(d, f(T, tt, ss * 0.5f, n - 1));
                ss *= 0.8f;
            }
        }

    return d;
}

int ribbon() {
    float x = (fmodf(sy, 0.1f) / 0.1f - 0.5f) * 0.5f;
    return sx >= x - 0.05f && sx <= x + 0.05f;
}

int main(int argc, char* argv[]) {
    int n = argc > 1 ? atoi(argv[1]) : 3;
    float zoom = argc > 2 ? atof(argv[2]) : 1.0f;
    for (sy = 0.8f; sy > 0.0f; sy -= 0.02f / zoom, putchar('\n'))
        for (sx = -0.35f; sx < 0.35f; sx += 0.01f / zoom) {
            if (f(0, 0, PI * 0.5f, 1.0f, n) < 0.0f) {
                if (sy < 0.1f)
                    putchar('.');
                else {
                    if (ribbon())
                        putchar('=');
                    else
                        putchar("............................#j&o"[rand() % 32]);
                }
            }
            else
                putchar(' ');
        }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

将代码保存为 milo_tree.c （如上），拿到电脑上跑一遍，感觉圣诞树的生成速度很慢，在 Linux 下编译，用 time 指令看看具体时间：

$ gcc milo_tree.c -o milotree -lm

$ time ./milotree
                                   .
                                   .
                                   .
                                  ==.
                                . o.. .
                            .  ......#..  .
                         ..... ....o.... .....
                                  ..=
                               == ==j ..
                            . .   &..   . .
                          .  .. ....... j#  .
                         ..&... # .&. & ..#...
                       . # . . .....==== = = = #
                              ======....#
                          .   .& ..... ..   .
                        . . ##  ...&...  #. . .
                     .. ...... . ..... . .....= ==
                  . j o    . & .#...==== = =    . . .
                            =    ===.&    .
                     =    .. .  ....&.#  . ..    .
                     .  . .... .....#... ...j .  .
                   . .  #o...... ..... ......j=  = =
                 .#o. .   ..........=========   . .&..
                .    .  .#===  =====....  ....&  .    .
                     =    ..j   .......   ...    .
              =  .   .  #......................  .   o  .
              . .  . .&.#.....................==== =  = &
              .........  ... .. ..&.=== == ===  .......&.
         #..       .  . ..=== = ====... . ..&.& .  .       ...
             . .=  =  == =.. . .......#. . ... ..  .  &. .
             =       ...  ...................  .o.       .
         .   . &#. ....................#.#..#.====== === .   .
     . .  .  ..#.....o...  .. . o...=== = ==  ............  .  . .
    .. .........  .. j..  ===  =====....  .o.  ... ..  ......... ..
...  .  .     . ==== == = .... ....&.... .... . .. .... .     .  .  ...
      =   =         .    &..  ......o....  ...    .         .   .
                         ..    .........    ..
                               .........
                               .........
                               .........
                               .........

./milotree  18.34s user 0.00s system 99% cpu 18.384 total
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

18384 毫秒，很慢的速度。扫一眼代码，里面的嵌套 for 和大量的浮点数运算可能是生成速度慢的原因。但对于新手来说，靠猜测去判断程序的瓶颈在哪里是很不靠谱的。

这里就需要使用专门的性能分析工具，Linux 平台可使用 gprof，Windows 平台的 Visual Studio 也有类似的功能。

这里我在 Linux 平台下演示，使用 grpof 需要在编译时加上 -pg 参数，然后运行一遍，才可以分析出来。如下指令：

$ gcc milo_tree.c -lm -pg -o milotree

$ ./milotree && gprof ./milotree

Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
 54.98      1.74     1.74     2911     0.60     1.03  f
 26.53      2.58     0.84 224976635     0.00     0.00  sdCircle
 13.51      3.00     0.43 230460959     0.00     0.00  opUnion
  5.40      3.17     0.17                             frame_dummy
  0.00      3.17     0.00      702     0.00     0.00  ribbon
...
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

可以看到，代码内的 f 函数是性能瓶颈，sdCircle()，opUnion() 函数的结构很简单，但由于调用次数接近 2 亿，也存在一定开销。

性能分析结束，开启 GCC 标准优化选项 O2 编译一遍：

$ gcc -O2 milo_tree.c -o milotree -lm && time ./milotree

...
./milotree  1.85s user 0.00s system 99% cpu 1.860 total
  • 1
  • 2
  • 3
  • 4

瞬间缩短到 1860 毫秒，9 倍左右的速度提升，这时 gprof分析一下，结果是：

Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  Ts/call  Ts/call  name    
100.57      1.68     1.68                             f

             Call graph (explanation follows)


granularity: each sample hit covers 2 byte(s) for 0.60% of 1.68 seconds

index % time    self  children    called     name
                             5484324             f [1]
[1]    100.0    1.68    0.00       0+5484324 f [1]
                             5484324             f [1]
-----------------------------------------------

Index by function name

   [1] f
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

可以看到，即使没有对 sdCircle() 和 opUnion() 加 inline 关键字，它们也被编译器自动展开了。

一般到这里，“优化” 就可以结束了。可一切都是编译器替我们做的，而且可能还期待执行速度可以更快一些。

这时，稍有一点经验的程序员可以从程序的具体实现入手。

接下来，从简单的函数开始，来分析优化点，看 sdCircle() 函数的代码：

float sdCircle(float px, float py, float r) {
    float dx = px - sx, dy = py - sy;
    return sqrtf(dx * dx + dy * dy) - r;
}
  • 1
  • 2
  • 3
  • 4

这里使用了 C 标准库的平方根算法的单精度浮点版本 sqrtf() 。这里提一下，标准库的实现都是稳健的，但不是所有都是高效率的。

在特定硬件平台，有专门的指令集提供这类数学上的运算指令，例如可以使用 C 的内联汇编来实现一个平方根运算：

// GCC 版本内联汇编，使用 SSE 指令集
float asm_sse_sqrtf(float x)
{
    float ret;

    // GCC inline assembly
    __asm__ __volatile__ (
        "rsqrtss %1, %%xmm0\n\t"
        "rcpss %%xmm0, %%xmm0\n\t"
        "movss %%xmm0, %0"
        : "=m"(ret)
        : "m"(x));

    return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

但是这个程序并不需要精确到小数点后几十位的程度，精度只要足够即可，否则只是浪费处理器的时钟周期。

这时，回忆起雷神之锤 3 经典的快速平方根倒数算法，里面利用了一个魔数 0x5f3759df 求平方根倒数的近似算法。当然，平方根也可以用魔数来快速运算，这篇文章提供了十几种快速平方根算法，其中就有几个是利用了魔数运算。

这里，我把上篇文章中的第 7 个算法简化，实现一个快速平方根运算函数，因为是为了优化，所以我定义成 inline 函数：

typedef unsigned int u32;

inline float f_sqrt(float x)
{
    u32 i = (*(u32 *) &x + 0x3f800000) >> 1;
    return *(float*) &i;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

因为至少需要 32 位的无符号整型才能满足运算的数值范围，由于现代编译器在 32 位和 64 位操作系统上，int 型都是 32 位，所以用 int 的无符号版本即可。 
另外，此算法可以通过牛顿迭代法来提高计算的精度，不过在此程序里没什么必要。

这时，再看一看代码，里面有个很慢的随机数算法 rand()，同样它是 C 标准库提供的。要优化这个算法，可以浏览这篇 Intel 的快速随机数算法文章 ，里面介绍的 LCG 算法比标准库实现快 5 倍左右。

为了一些便利，我用 C++ 替代 C 来写 LCG 算法，并用 C 标准库 time() 的返回值作为种子值，确保每次运行时圣诞树的装饰都不一样:

...
#include <ctime>

typedef unsigned int u32;

class LCG {
public:
    LCG(u32 seed) : mSeed(seed) {}
    u32 operator()() {
        mSeed = mSeed * 214013U + 2531011U;
        return (mSeed >> 16U) & 0x7FFFU;
    }
private:
    u32 mSeed;
};

...
int main(int argc, char *argv[])
{
...
    LCG rng(time(0));
...
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

编译、运行：

$ g++ i.cc -O2 && time ./a.out

./a.out  1.67s user 0.00s system 99% cpu 1.682 total
  • 1
  • 2
  • 3

可以看到比原来的代码快了 200 毫秒左右。

这时候，再对 f 函数下手，浏览一下此函数的代码。第一个 for 循环进行 40 次迭代，虽然看似很简单，但是把宏

#define T px + scale * r * cos(theta), py + scale * r * sin(theta)
  • 1

替换进去，可以看到里面包含了平方根，正弦，余弦的运算，实际整个函数的瓶颈就在此处，应该重点优化。但由于这个 for 循环是浮点数运算，且每次迭代都会用到上一次的结果，想要使用 OpenMP 做并行很难，且效果差。 
但稍微理解下 f() 函数的用意后，可以利用 opUnion() 函数做模拟并行，具体代码如下：

#define T px + scale * r * f_cos(theta), py + scale * r * f_sin(theta)

#define T2 px + scale * (r + 0.02f) * cos(theta), py + scale * \
        (r + 0.02f) * sin(theta)

float f(float px, float py, float theta, float scale, int n)
{
    float d = 0.0f, di = 0.0f;
    float ret;

    for (float r = 0.0f; r < 0.8f; r += 0.04f) {
        d = opUnion(d, sdCircle(T, 0.05f * scale * (0.95f - r)));
        di = opUnion(di, sdCircle(T2, 0.05f * scale * (0.93f - r)));
    }

    ret = opUnion(d, di);

    if (n > 0)
        for (int t = -1; t <= 1; t += 2) {
            float tt = theta + t * 1.8f;
            float ss = scale * 0.9f;

            for (float r = 0.2f; r < 0.8f; r += 0.1f) {
                ret = opUnion(ret, f(T, tt, ss * 0.5f, n - 1));
                ss *= 0.8f;
            }
        }

    return ret;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

接下来对 sin() 和 cos() 动手，虽然不知道有没有魔数的方法来求近似值，但学过高数的同学会知道这两个函数都可以用泰勒级数来求近似值。由于上面提到精度足够即可，在具体实现中我只迭代了 10 次。具体实现如下：

// sin(x) = x - (x^3 / 3!) + (x^5 / 5!) - (x^7 / 7!) + ...
template <typename T>
T f_sin(const T& x)
{
    const T x2 = x * x;
    T power = x;
    T facter = 1;
    T sign = 1;
    T sum = 0;
    const int loop = 22;  // 10 times loop

    for (int i = 3; i < loop; i += 2) {
        sign *= -1;
        power *= x2;
        facter *= i * (i - 1);
        sum += sign * power / facter;
    }
    return sum + x;
}

// cos(x) = 1 - (x^2 / 2!) + (x^4 / 4!) - (x^6 / 6!) + ...
template <typename T>
T f_cos(const T& x)
{
    const T x2 = x * x;
    T power = 1;
    T facter = 1;
    T sign = 1;
    T sum = 0;
    const int loop = 21;  // 10 times loop

    for (int i = 2; i < loop; i += 2) {
        sign *= -1;
        power *= x2;
        facter *= i * (i - 1);
        sum += sign * power / facter;
    }
    return sum + 1;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

因为这个两个函数实现可用于整型运算，所以我写成模板的形式。可能有更优雅的实现方式，而我只是按照公式写出实现。但这没什么，一切都可以交付给强大的编译器，去优化我的代码。

这时，如果用的是 GCC 编译器，可以

  • 开启 -ffast-math 选项来加速浮点数运算;
  • 开启 -march=native 来让编译器做本地处理器架构优化;
  • 开启最高等级优化选项 -O3，O3 和 fast-math 可以合写成 -Ofast：
$ g++ -Ofast -march=native i.cc && time ./a.out

$ gcc -Ofast -march=native milo_tree.c -o milotree -lm && time ./milotree

./a.out  0.35s user 0.00s system 99% cpu 0.350 total

./milotree  0.95s user 0.01s system 96% cpu 0.990 total
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Milo Yip 的版本是 88 毫秒，优化后的是 35 毫秒，可能会觉得没有太大提升，这时把圣诞树大小放大 10 倍，来直观感受一下两者执行速度的差距：

$ g++ -Ofast -march=native i.cc && time ./a.out 3 10

$ gcc -Ofast -march=native milo_tree.c -o milotree -lm && time ./milotree 3 10

./a.out 3 10  34.01s user 0.01s system 99% cpu 34.139 total

./milotree 3 10  90.25s user 0.01s system 99% cpu 1:30.32 total
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

Milo Yip 的版本是 1 分 30 秒 32 
优化后的版本是 34 秒 139

因此可以说一个好的算法，或者说一个适合的算法，在程序中发挥着重要作用。因此我们可以得出以下结论：

  • 如果程序对性能没有极高的需求，就直接用编译器来为我们做优化;
  • 在运算量较大的场合，可以适当取近似值来优化运算的开销;
  • 为具体需求选择合适的代码实现

当然，编译器优化并非百利而无一害，比如对运算精度需求极高的程序，千万不可开启 -ffast-math ; 
在较底层的代码中，会因为过度依赖编译器的优化选项，而造成现有代码无法直接迁移到编译器的更新版本上（比如 Linux 内核的某些底层实现、硬件驱动等，就过度依赖 GCC 的某一版本），去年我在 Linux 3.4 内核中也发现过类似问题

对性能做到良好取舍，写出合适的代码，都不是一日之功，希望日后可以有更多机会继续深入地学习相关方面的知识。

注：
imJaron
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 应用程序性能优化 第二版
03-07
本资源只是业余学习之用，如有涉及侵权，还请其他告知，谢谢
C++应用程序性能优化（三）——C++语言特性性能分析
weixin_34357436的博客
06-07 409
C++应用程序性能优化（三）——C++语言特性性能分析 一、C++语言特性性能分析简介 通常大多数开发人员认为，汇编语言和C语言比较适合编写对性能要求非常高的程序，C++语言主要适用于编写复杂度非常高但性能要求并不是很高的程序。因为大多数开发人员认为，C++语言设计时因为考虑到支持多种编程模式（如面向对象编程和范型编程）以及异常处理等，从而引入了太多新的语言特性。新的语言特性往往使得C++编译器在...
C++——程序性能分析
摸鱼中......
03-01 1026
C++——程序性能分析一、程序性能1.空间复杂度2.时间复杂度二、渐进记法总结
C/C++语言性能分析方法及性能分析工具的使用
qq_41854911的博客
12-30 7869
文章目录一、从算法复杂度都程序性能一、事后统计的方法二、事前分析估算的方法三、求解算法的时间复杂度的具体步骤四、算法复杂度和程序性能之间的关系五、执行什么语句耗时？不同语句执行时间量级分析整型加和减：浮点型加和减测试打印printf函数调用二、程序性能分析工具1.gprofgprof介绍gprof安装gprof使用步骤实战一：用gprof测试基本函数调用及控制流测试代码操作步骤 一、从算法复杂度都程序性能 我们第一次接触关于代码性能相关概念，应该是在学数据结构中的算法时间复杂度上面。 算法的时间复杂度反映了
C++ 性能剖析
大鹏的blog
05-16 613
两个性能隐患性能问题不是仅仅用“技术”可以解决的，它往往是架构，测试，假设等综合难题。不过，对于一个工程师来说，必须从小做起，把一些“明显”的小问题解决。否则的话积小成多，千里堤坝，溃于蚁穴。 下面用一例子，来做一下对比，看看一些微妙的细节是如何影响程序性能的。struct intPair { int ip1; int ip2;
C++应用程序性能优化_第二版
04-06
C++应用程序性能优化 第二版 高清图书 相当经典相当不从的，取于网络，还于网络，亲给个好评啊！！
关于C与C++程序的优化问题
01-19
　对C＋＋程序的优化一定是大多数程序员感兴趣的话题，在此先说说基于C，C＋＋的代码优化，希望能起到抛砖引玉的作用。 　1、在 ANSI/ISO C/C++规范中明确建议：“不要使用macro和。h，应该使用程序中的常量定义和 ...
【超级好】C++应用程序性能优化.pdf
11-14
C++应用程序性能优化C++应用程序性能优化
c++应用程序性能优化
06-27
本书深入浅出的讲解了C++性能优化，由程序优化基础，内存使用优化，程序启动性能优化以及性能工具4部分组成
C++程序分析及运行结果
10-29
本课程主要掌握C++语言的基本语法，以及面向对象程序设计与分析，重点掌握面向对象中类与对象的定义及调用，运算符函数重载，继承性与多态性的运用，理解掌握C++中输入输出流类和模板的使用。最终达到能够简单的、综合的面向对象程序设计能力。
C++开发的股票分析系统的原代码程序
10-28
C++开发的股票分析系统的原代码程序
c++ 程序分析题目及运行结果
06-17
C++很好的习题资料，程序都完全正确，可以作为自学C++的不错选择.
STM32 随机数产生测试
wxynj的博客
03-09 652
#include "stdlib.h" void testRand(){ u32 seed = HAL_GetUIDw0(); printf("seed:%08x\n",seed); srand(seed); for(int i=0;i<10;i++){ u32 data = rand()%3600; printf("%04d\n",data); } }
[转]快速计算平方根倒数的一个算法
looongson的专栏
03-09 3332
 在3D图形编程中，经常要求平方根或平方根的倒数，例如：求向量的长度或将向量归一化。C数学函数库中的sqrt具有理想的精度，但对于3D游戏程式来说速度太慢。我们希望能够在保证足够的精度的同时，进一步提高速度。Carmack在QUAKE3中使用了下面的算法，它第一次在公众场合出现的时候，几乎震住了所有的人。据说该算法其实并不是Carmack发明的，它真正的作者是Nvidia的Gary Tar
三种求平方根的算法——C/C++
有人_295的博客
06-10 4万+
1、二分法 这种是最简单的，就是定义一个最小值0和最大值number，把一个数取一个中间值（0+number）/2，然后平方，如果平方大于该数值，就把中间值赋给最大值，否者就把中间值赋给最小值，一直循环，直到取到想要的精度为止 代码如下： //二分法 double sqrt1(double x){ double EPSINON = 0.00001; double low = 0.0; do...
一个Sqrt函数运算最快算法
hhpingyear的博客
12-30 1549
sqrt 最快
opencv中的Circle函数
热门推荐
yangfengman的博客
10-09 6万+
cvCircle(CvArr* img, CvPoint center, int radius, CvScalar color, int thickness=1, int lineType=8, int shift=0) img为源图像指针 center为画圆的圆心坐标 radius为圆的半径 color为设定圆的颜色，规则根据B（蓝）G（绿）R（红）
性能优化：使用距离平方而不是距离
成长ing中的w的专栏
11-28 1274
CPU比较擅长浮点数相乘，但不擅长计算它们的平方根。magnitude属性，Distance()方法，会执行平方根计算，会消耗大量的CPU开销。sqrMagnitude属性，距离的平方，但不需要昂贵平方根计算。 using System.Collections; using System.Collections.Generic; using UnityEngine; /* * Author:W * 距离的平方 */ public class SqrMagnitudeTest : MonoBehavio
贪吃蛇c++课题程序性能分析与评价
最新发布
05-20
贪吃蛇游戏是一款非常经典的小游戏，但是在...综上所述，对于贪吃蛇游戏的程序性能分析与评价，需要综合考虑程序的时间复杂度、内存分配和释放、算法优化、图形渲染优化等方面，并通过压力测试来评估程序的性能表现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值