深入理解计算机系统 第5章 优化程序性能

最新推荐文章于 2023-08-31 13:06:26 发布
最新推荐文章于 2023-08-31 13:06:26 发布
阅读量331 收藏 1
点赞数
分类专栏： 深入理解计算机系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43627561/article/details/113457267
版权

优化

编译器必须很小心地对程序只使用安全的优化

在这里插入图片描述
乍一看，这两个过程似乎有相同的行为。

不过，考虑xp等于yp的情况

内存别名使用：两个指针可能指向同一个内存位置
在这里插入图片描述
在这里插入图片描述

函数调用。大多数编译器不会试图判断一个函数是否没有副作用

每元素的周期数CPE

千兆赫兹GHz。“4GHz”处理器，这表示处理器时钟运行频率为每秒4X10 9个周期

void psum1(float a[], float p[],long n)
{
    long i;
    p[0] = a[0];
    for(i = 1; i < n; i++)
        p[i] = p[i-1]+a[i];
}

void psum2(float a[], float p[],long n)
{
    long i;
    p[0] = a[0];
    for(i = 1; i < n-1; i+=2){
        float mid_val = p[i-1] + a[i];
        p[i] = mid_val;
        p[i+1] = mid_val + a[i+1];    
    }
    if(i<n)
            p[i] = p[i-1] + a[i];
}

循环展开
psuml和psum2的运行时间（用时钟周期为单位）分别近 似于等式368 + 9.0n和368 + 6.0n。
在这里插入图片描述
psum2的CPE为6.0,优于CPE为9. 0的psum1

void combine1(vec_ptr v,data_t *dest)
{
    long i;

    *dest = IDENT;
    for(int i = 0; i < vec_length(v); i++){
        data_t val;
        get_vec_element(v,i,&val);
        *dest = *dest OP val;
    }
}

void combine2(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);

    *dest = IDENT;
    for(i = 0; i < length; i++){
        data_t val;
        get_vec_element(v,i,&val);
        *dest = *dest OP val;
    }
}

代码移动
执行多次（例如在循环里）但是计算结果不会改变的计算

data_t *get_vec_start(vec_ptr v)
{
    return v->data;
}

void combine3(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t *data = get_vec_start(v);

    *dest = IDENT;
    for(i = 0; i < length; i++){
        *dest = *dest OP data[i];
    }
}

减少过程调用，性能并没有明显提升

combine3
在这里插入图片描述

void combine4(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t *data = get_vec_start(v);
    data_t acc = IDENT;

    for(i = 0; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

在这里插入图片描述

消除不必要的内存引用

由于内存别名使用，编译器不会将combine3转换为combine4，如下

combine3(v, get_vec_start(v) + 2);
combine4(v, get_vec_start(v) + 2);

理解现代处理器

延迟界限：在下一条指令开始之前，这条指令必须结束。代码数据相关限制处理器利用指令级并行的能力时

吞吐量界限：刻画处理器功能单元原始计算能力。程序性能的终极限制

超标量(superscalar), 意思是它可以在每个时钟周期执行多个操作，而且是乱序的(out-oforder),意思就是指令执行的顺序不一定要与它们在机器级程序中的顺序一致

指令控制单元(Instruction Control Unit, ICU)和执行单元(Execution Unit, EU)
在这里插入图片描述
Intel Core i7 Haswell参考机有8个功能单元
0：整数运算、浮点乘、整数和浮点数除法、分支
1：整数运算、浮点加、整数乘、浮点乘
2：加载、地址计算
3：加载、地址计算
4：存储
5：整数运算
6：整数运算、分支
7：存储、地址计算

退役单元记录正在进行的处理。
一旦一条指令的操作完成了，而且所有引起这条指令的 分支点也都被确认为预测正确，那么这条指令就可以退役了，有对程序寄存器 的更新都可以被实际执行了
如果引起该指令的某个分支点预测错误，这条指令会被清空(,丢弃所有计算出来的结果。通过这种方法，预测错误就不会改变程序的状态了。
任何对程序寄存器的更新只会在指令退役时才会发生

寄存器重命名：操作数在执行单元传送。
一条更新寄存器r的指令译码时，产生标记t，条目(r,t)被加入表中。随后以r为操作数时，发送t。
重命名表只包含未进行写操作的寄存器条目

在这里插入图片描述
延迟：完成需要时间
发射时间：两个连续的同类型运算之间需要最小时钟周期数
容量：执行该运算功能单元数量

吞吐量：发射时间的导数，容量c，发射时间I，吞吐量C/I

发射时间为1的称为完全流水线化的

CPE
在这里插入图片描述
由于只有两个加载单元，导致一周期只能读两个数据，吞吐量界限0.50
在这里插入图片描述
在这里插入图片描述

访问的寄存器分为4类：只读、只写、局部（单次迭代）、循环（多次迭代）
在这里插入图片描述

在这里插入图片描述

void combine5(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length - 1;
    data_t *data = get_vec_start(v);
    data_t acc = IDENT;

    for(i = 0; i < limit; i+=2){
        acc = (acc OP data[i]) OP data[i+1];
    }

    for(; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

循环展开：一个循环按任意因子k进行展开，由此每次产生k×1循环展开，上限设为n-k+1
在这里插入图片描述
在这里插入图片描述
提高并行性

我们将累积值放在一个单独的变量acc中，会有数据相关

void combine6(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length-1;
    data_t *data = get_vec_start(v);
    data_t acc0 = IDENT;
    data_t acc1 = IDENT;

    for(i = 0; i < limit; i+=2){
        acc0 = acc0 OP data[i];
        acc1 = acc1 OP data[i+1];
    }
    
    for(; i < length; i++){
        acc0 = acc0 OP data[i];
    }
    *dest = acc0 OP acc1;
}

两次循环展开 2×2循环展开
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
重新结合变换

void combine7(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length - 1;
    data_t *data = get_vec_start(v);
    data_t acc =IDENT;

    for(i = 0; i < limit; i+=2){
        acc = acc OP (data[i] OP data[i+1]);
    }

    for(; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

combine5 12 acc = (acc OP data[i]) OP data[i+1];
combine7 12 acc = acc OP (data[i] OP data[i+1]);

2×1a的循环展开形式
在这里插入图片描述
在这里插入图片描述

只有一个数据相关

限制因素

寄存器溢出
在这里插入图片描述
x86-64有16个寄存器，16个ymm寄存器保存浮点数

分支预测

不要过分关心可预测的分支
在这里插入图片描述
这些检测总是确定索引是在界内，所以是高度可预测的

void combine4(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t *data = get_vec_start(v);
    data_t acc = IDENT;

    for(i = 0; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

void combine4b(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t acc = IDENT;

    for(i = 0; i < length; i++){
        if(i >=0 && i < v->len){
            acc = acc OP v->data[i];
        }
    }
    *dest = acc;
}

在这里插入图片描述
对于整数加法来说，会慢一点

条件传送

void minmax1(long a[], long b[],long n){
    long i;
    for(i = 0; i < n; i++){
        if(a[i]>b[i]){
            long t = a[i];
            a[i] = b[i];
            b[i] = t;
        }
    }
}

void minmax2(long a[],long b[],long n){
    long i;
    for(i = 0; i < n; i++){
        long min = a[i]<b[i]?a[i]:b[i];
        long max = a[i]<b[i]?b[i]:a[i];
        a[i] = min;
        b[i] = max;
    }
}

minmax1 CPE 13.50 minmax2 CPE 4.0

内存性能

typedef struct ELE{
    struct ELE *next;
    long data;
} list_ele, *list_ptr;

long list_len(list_ptr ls){
    long len = 0;
    while(ls){
        len++;
        ls = ls->next;
    }
    return len;
}

.L3:
  addq $1, %rax
  movq (%rdi), %rdi
  testq %rdi, %rdi
  jne   .L3

movq是循环中关键瓶颈
CPE 4.0 与L1cache的4周期访问时间一致

存储的性能

void clear_array(long *dest, long n){
    long i;
    for(i = 0; i < n; i++)
        dest[i] = 0;
}

CPE1.0

写读相关

void write_read(long *src, long *dst, long n)
{
    long cnt = n;
    long val = 0;

    while(cnt){
        *dst = val;
        val = (*src)+1;
        cnt--; 
    }
}

CPE 7.3
在这里插入图片描述

程序剖析

Unix提供一个剖析程序GPROF，确定程序每个函数花费多少cpu时间，计算函数调用次数

1)程序必须为剖析而编译和链接，确保不优化
gcc -Og -pg prog.c -o prog

2)像往常一样执行
./prog file.txt
大约慢两倍，产生gmon.out

3)调用gprof来分析
gprof prog

第一部分是执行各个函数花费的时间
第二部分是函数调用历史

本节代码

#include <bits/stdc++.h>
#define IDENT 1
#define OP +
using namespace std;

void psum1(float a[], float p[],long n)
{
    long i;
    p[0] = a[0];
    for(i = 1; i < n; i++)
        p[i] = p[i-1]+a[i];
}

void psum2(float a[], float p[],long n)
{
    long i;
    p[0] = a[0];
    for(i = 1; i < n-1; i+=2){
        float mid_val = p[i-1] + a[i];
        p[i] = mid_val;
        p[i+1] = mid_val + a[i+1];    
    }
    if(i<n)
            p[i] = p[i-1] + a[i];
}

typedef long data_t;

typedef struct{
    long len;
    data_t *data;
}vec_rec, *vec_ptr;

vec_ptr new_vec(long len)
{
    vec_ptr result = (vec_ptr) malloc(sizeof(vec_rec));
    data_t *data = NULL;
    if(!result)
        return NULL;
    result->len = len;
    if(len > 0){
        data = (data_t *)calloc(len, sizeof(data_t));
        if(!data){
            free((void *)result);
            return NULL;
        }
    }
    result->data = data;
    return result;
}

int get_vec_element(vec_ptr v,long index, data_t *dest)
{
    if(index < 0 || index >= v->len)
        return 0;
    *dest = v->data[index];
    return 1;
}

long vec_length(vec_ptr v)
{
    return v->len;
}

void combine1(vec_ptr v,data_t *dest)
{
    long i;

    *dest = IDENT;
    for(int i = 0; i < vec_length(v); i++){
        data_t val;
        get_vec_element(v,i,&val);
        *dest = *dest OP val;
    }
}

void combine2(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);

    *dest = IDENT;
    for(i = 0; i < length; i++){
        data_t val;
        get_vec_element(v,i,&val);
        *dest = *dest OP val;
    }
}

data_t *get_vec_start(vec_ptr v)
{
    return v->data;
}

void combine3(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t *data = get_vec_start(v);

    *dest = IDENT;
    for(i = 0; i < length; i++){
        *dest = *dest OP data[i];
    }
}

void combine4(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t *data = get_vec_start(v);
    data_t acc = IDENT;

    for(i = 0; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

void combine4b(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    data_t acc = IDENT;

    for(i = 0; i < length; i++){
        if(i >=0 && i < v->len){
            acc = acc OP v->data[i];
        }
    }
    *dest = acc;
}

void combine5(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length - 1;
    data_t *data = get_vec_start(v);
    data_t acc = IDENT;

    for(i = 0; i < limit; i+=2){
        acc = (acc OP data[i]) OP data[i+1];
    }

    for(; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

void combine6(vec_ptr v,data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length-1;
    data_t *data = get_vec_start(v);
    data_t acc0 = IDENT;
    data_t acc1 = IDENT;

    for(i = 0; i < limit; i+=2){
        acc0 = acc0 OP data[i];
        acc1 = acc1 OP data[i+1];
    }

    for(; i < length; i++){
        acc0 = acc0 OP data[i];
    }
    *dest = acc0 OP acc1;
}

void combine7(vec_ptr v, data_t *dest)
{
    long i;
    long length = vec_length(v);
    long limit = length - 1;
    data_t *data = get_vec_start(v);
    data_t acc =IDENT;

    for(i = 0; i < limit; i+=2){
        acc = acc OP (data[i] OP data[i+1]);
    }

    for(; i < length; i++){
        acc = acc OP data[i];
    }
    *dest = acc;
}

void minmax1(long a[], long b[],long n){
    long i;
    for(i = 0; i < n; i++){
        if(a[i]>b[i]){
            long t = a[i];
            a[i] = b[i];
            b[i] = t;
        }
    }
}

void minmax2(long a[],long b[],long n){
    long i;
    for(i = 0; i < n; i++){
        long min = a[i]<b[i]?a[i]:b[i];
        long max = a[i]<b[i]?b[i]:a[i];
        a[i] = min;
        b[i] = max;
    }
}

typedef struct ELE{
    struct ELE *next;
    long data;
} list_ele, *list_ptr;

long list_len(list_ptr ls){
    long len = 0;
    while(ls){
        len++;
        ls = ls->next;
    }
    return len;
}

void clear_array(long *dest, long n){
    long i;
    for(i = 0; i < n; i++)
        dest[i] = 0;
}

void write_read(long *src, long *dst, long n)
{
    long cnt = n;
    long val = 0;

    while(cnt){
        *dst = val;
        val = (*src)+1;
        cnt--; 
    }
}

int main()
{

}
mygfze
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《深入理解计算机系统》学习笔记——优化程序性能
weixin_45243288的博客
11-05 338
计算机系统——优化程序性能优化程序性能优化编译器的能力和局限性表示程序性能理解现代处理器整体操作功能单元的性能处理器操作的抽象模型循环展开提高并行性多个累积变量重新结合变换一些限制因素寄存器溢出分支预测和预测错误处罚理解内存性能加载的性能存储的性能应用：性能提高技术 优化程序性能 编写高效程序需要做到以下几点： 第一，我们必须选择一组适当的算法和数据结构。 第二，我们必须编写出编译器能够有效优化以转换成高效可执行代码的源代码。 第三项技术针对处理运算量特别大的计算，将一个任务分成多个部分，这些部分可以在多核
程序性能优化之表示程序性能
私のBookShelf
12-15 548
表示程序性能 CPE： Cycles Per Element，每元素的周期数，作为表示程序性能的表示方法 处理器活动的顺序由时钟控制，其提供某个频率的规律信号，数量级为GHz 使用时钟周期表示，度量值表示的是执行了多少条指令。 许多过程含有在一组元素上迭代的循环。 void psum1(float a[], float p[], long n) { long i; p[0] = a[0]; for (i = 1; i < n; i ++) p[i] = p[i - 1] + a[i]; }
计算机系统：CPE（Cycles Per Element）详解
m0_72410588的博客
08-31 1877
在介绍CPE之前，我们需要先理解两个基本概念：周期数（Cycles）和元素（Element）。周期数：处理器执行一个指令所需的时钟周期数。时钟周期是计算机系统中的基本时间单位，它的频率由处理器的主频决定。元素：指的是在计算任务中需要处理的数据单元，可以是数组、矩阵、图像等。元素的数量决定了计算任务的规模。CPE即每个元素的周期数，它描述了处理器在执行特定计算任务时，每个元素所需的平均时钟周期数。CPE值越小，表示处理器执行相同计算任务时的效率越高。
优化程序性能
tangfatter的博客
12-29 413
注：以下所有内容均来自开源学习组织DataWhale 优化程序性能 编写高效程序需要满足以下条件： 选择合适的算法和数据结构 理解编译器的能力和局限性 探索并行化 编译器优化程序的局限性 例C代码如下： void add1(long *xp, long *yp) { *xp += *yp; *xp += *yp; } void add2(long *xp, long *yp) { *xp += 2 * *yp; } 两者功能相同，都是将指针yp指向的数两次加到指针xp指向的
计算机系统课程 笔记总结 CSAPP第五章 优化程序性能（5.1-5.14）
Zhuoning Guo's Blog
02-09 4154
GitHub计算机系统CSAPP课程资源 计算机系统课程 笔记总结 CSAPP第二章 信息的表示和处理（2.1-2.2） 计算机系统课程 笔记总结 CSAPP第二章 信息的表示和处理（2.3-2.4） 计算机系统课程 笔记总结 CSAPP第三章 程序的机器级表示（3.2-3.4） 计算机系统课程 笔记总结 CSAPP第三章 程序的机器级表示（3.5-3.7） 计算机系统课程 笔记总结 ...
深入理解计算机系统第五章参考文献整理
04-09
深入理解计算机系统第五章优化程序性能，参考文献整理。包括Patterson的经典著作量化研究方法，Mahlke描述的几种为编译器开发的将程序映射到并行机器上的技术，如循环展开、多个累计变量等等。额外包括几篇2002年...
深入理解计算机系统 第二版 习题答案 pdf
06-04
《深入理解计算机系统》是计算机科学领域的一部经典著作，由Randal E. Bryant和David R. O'Hallaron合著。这本书以其深入浅出的讲解方式，深受全球程序员、计算机科学家以及计算机工程专业学生的喜爱。它从硬件、...
深入理解计算机系统答案.docx
01-15
《深入理解计算机系统》这本书是计算机科学的经典之作，它涵盖了计算机系统的多个重要方面，包括硬件、软件、编程语言和系统设计。以下是对书中的部分知识点的详细解释： 1. **数值计算**： - **截断与模运算**：...
《深入理解计算机系统》第3版中文笔记
最新发布
12-24
《深入理解计算机系统》第三版是一本经典的计算机科学教材，旨在帮助读者全面了解计算机系统的运行机制。这本书结合了《计算机是怎样跑起来的》和《程序是怎样跑起来的》中的核心概念，通过综合讲解，使读者能够从...
C程序性能优化方法（二）
枫潇潇
06-26 1350
2.3 程序示例 1 /* Creat abstract data type for vector */ 2 typedef struct 3 { 4 long len; 5 data_t *data; 6 }vec_rec, *vec_ptr; 7 /* Creat vector of specified length */ 8 vec_p...
CSAPP:优化程序性能(一)
Immanito
06-20 1794
编写高效程序需要做到以下几点： 第一，必须选择一组适当的算法和数据结构 第二，必须编写出编译器能够有效优化以转换高效可执行代码的源代码（理解优化编译器的能力和局限性很重要） 程序员必须在实现和维护程序的简单性和运算速度之间做出权衡，几分钟就能编写一个简单的插入程序，而一个高效的排序算法程序可能需要一天或更长时间来实现和优化， 大多数编译器，例如GCC向用户提供了一些对它们所使用的优化的限制
关于代码编写过程中的性能优化的理解
zhpnp的博客
06-15 1188
示例程序private long mSum; long combine1(long[] v){ long i; for(i = 0; i &lt; getLength(v) ; i++){ long val = getElement(v,i); mSum = mSum + val; } return mSum; ...
深入理解计算机操作系统（八）
小时候挺菜的博客
07-23 353
阅读经典——《深入理解计算机系统》07 本文将介绍非常实用的程序性能优化手段，并用一个案例来详细说明。 为什么要优化程序性能？ 衡量性能的指标 未优化版本 提取重复操作 减少函数调用 避免内存读写 还能进一步优化吗？ 循环展开 提高并行性 重结合变换 总结 为什么要优化程序性能？ 对于c代码而言，从源代码到汇编代码再到机器指令，这中间是有一个编译器在起作用的。编译器...
复旦大学961-计算机系统基础-第二章-优化程序性能
iioSnail的博客
12-27 913
优化程序性能 《CSAPP》P341 选择合适的算法和数据结构 编写出编译器能够有效优化以转换成高效可执行代码的源代码 消除不必要的功能，让代码尽可能有效地执行所期望的任务。如不必要的函数调用，条件测试和内存引用。 优化编译器的能力和局限性以及表示程序性能 《CSAPP》P342 特定体系结构或应用特性的性能优化 限制因素 确认和消除性能瓶颈 ...
CSI-VI:程序性能优化-写出快速、高效代码
天将降大任于斯人....
04-10 1446
前言          我们常常关注程序的性能，而程序性能的一个重要参考就是:运行时间，同时，我们都知道，这也是衡量一个算法好坏的重要标准。在一个程序保证正确的前提下，其运行得快慢往往决定了其性能的好坏。当然，并不是所有的程序都有很严格的性能要求，往往这些程序更加倾向于保证程序的正确性及稳定性，性能是其次需要考虑的。但对于某些实时性要求比
优化程序性能的几个方法（来自于《深入理解计算机系统》）
Cyberspace
04-10 1051
这部分的代码出自《深入理解计算机系统》（CS:APP）第五章，其目的是通过手工改变代码结构，而不是算法效率和数据结构优化，提高执行效率。有些编译器在某些优化选项下可能会做出类似的改动。 　　为了便于以后的查阅和使用，本文进行了摘录和简要分析，其中包含了一些个人理解。对于更深层次的原理如汇编、处理器结构等请参考原书。 　　大致地，越靠后的代码性能越好，版本6和7性能近似，版本6略好一些。二者均能
for循环次数太多的时间优化_第五章 优化程序性能(二）优化背后的原理
weixin_42517569的博客
12-06 1437
上一篇讲到，现在我们还有两个问题，第一，为什么上一步减少get_vec_element的优化，看起来没有作用。第二，combine4是否还有进一步优化的空间。要回答这两个问题，我们需要先稍微了解一下现代处理器的一些内部操作流程。5.7 理解现代处理器前面都是些基本的优化操作：降低循环的低效率减少函数调用消除存储器引用，使用临时变量这几个方法都是处理器无关的，不依赖任何机器特性。接下来，就要利用处理...
带你学习《深入理解计算机系统》程序性能优化探讨（1）——周期计数器与循环展开
u013471946的专栏
10-21 1555
周期计数器与循环展开
深入理解操作系统（13）第五章：优化程序性能（1）表示程序性能+优化措施（包括：存储器別名使用/程序序性能表示：每元素的周期数(CPE)/降低循环低效率：（循环中）代码移动/循环中减少过程调用）
哈尼的博客
12-03 1509
深入理解操作系统（13）第五章：优化程序性能（1）表示程序性能+优化措施（包括：程序示例/降低循环低效率/减少过程调用）1. 前沿1.1 高效程序的两类活动1.2 开发和优化过程中的关键因素1.3 本章目标-提高代码性能1.3.1 妨碍优化因素1.3.2 两种编译技术: 与机器无关 和 与机器有关1.3.3 代码剖析程序(profilers)2. 优化编译器的能力和局限性2.1 编译器优化程序受限制的几个因素2.2 例子说明2.2.1 例子2.2.2 妨碍优化因素一：存储器別名使用2.2.3 妨碍优化因素二
深入理解计算机系统第二版：第1-3章概览
"深入理解计算机系统 第二版 part1" 深入理解计算机系统，简称CSAPP，是由Randal E. Bryant和David R. O'Hallaron共同编著的一本计算机科学领域的经典教材。这本书全面介绍了计算机系统的基本概念，从硬件到软件，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值