使用OpenMP+MPI实现PSRS排序

最新推荐文章于 2024-04-01 01:26:26 发布
原创 最新推荐文章于 2024-04-01 01:26:26 发布 · 835 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #c++ #并行计算

总体建立在MPI框架上，中间一些局部排序使用openMP实现的PSRS排序。

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <mpi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "unistd.h"
#include <algorithm>
#include <time.h>
#include <string.h>
#define BLOCK 1024*1024
#define ERO if(!myRank) 
class OmpPsrs
{
public:
	OmpPsrs(){
		vdata = NULL;
		sampleList = NULL;
		primarySamples = NULL;
		sortPoint = NULL;
		primaryDividePoint = NULL;
	}

	~OmpPsrs(){};
	//运行OpenMP实现的PSRS排序
	double* run(double* dataSet, int dataSize) {
		double* swapData = NULL;
		thread_count = 32;
		todo = dataSize / thread_count;

		vdata = dataSet;

		sampleList = (double*)malloc(sizeof(double)*thread_count*thread_count);
	#	pragma omp parallel num_threads(thread_count)
		selectSamples();


		//select samples
		std::sort(sampleList, sampleList + thread_count*thread_count);
		primarySamples = (double*)malloc(sizeof(double)*(thread_count - 1));
		for (int i = 0;i < thread_count - 1;++i) primarySamples[i] = sampleList[(i + 1)*thread_count];
		primaryDividePoint = (double**)malloc(sizeof(double*)*(thread_count*thread_count + 1));

	#	pragma omp parallel num_threads(thread_count)
		primaryDivide();

		//global swap
		primaryDividePoint[thread_count*thread_count] = vdata + dataSize;

		int pointer = 0;
		sortPoint = (int*)malloc(sizeof(int)*(thread_count + 1));
		swapData = (double*)malloc(sizeof(double)*dataSize);
		sortPoint[0] = 0;
		for (int processer = 0; processer < thread_count; ++processer) {
			for (int segment = 0; segment < thread_count; ++segment)
			{
				double* head = primaryDividePoint[segment*thread_count + processer];
				double* tail = primaryDividePoint[segment*thread_count + processer + 1];
				for (double* i = head;i < tail;++i) {
					swapData[pointer++] = *i;
				}
			}
			sortPoint[processer + 1] = pointer;
		}
		free(vdata);

	#	pragma omp parallel num_threads(thread_count)
		lastSort(swapData);
		//printf("time to OmpPsrs sort :%fs\n", (double)(stop - start)/CLOCKS_PER_SEC);
		//printf("%d\n", dataSet[todo-1]);
		//printf("%d\n", dataSet[0]);

		/*bool check = true;
		for (int i = 0;i < dataSize - 1;++i) if (swapData[i]>swapData[i + 1]) check = false;
		if (check) printf("pass check\n\n");*/

		return swapData;
	}
private:
	int 			todo; 				/*各线程分配的数据数量	*/
	int 			thread_count;  		/*线程数				*/
	double* 		vdata;				/*各线程数据 			*/
	double* 		sampleList; 		/*采样数组				*/
	double* 		primarySamples;		/*主元数组				*/
	int* 			sortPoint;			/*全局交换点			*/
	double** 		primaryDividePoint;	/*划分点				*/
	
	void selectSamples() {
		//选择样本
		int my_rank = omp_get_thread_num();
		int start = my_rank * todo;
		int end = start + todo;

		std::sort(vdata + start, vdata + end);

		int sampleStride = todo / thread_count;
		for (int i = 0;i < thread_count;++i) sampleList[my_rank*thread_count + i] = vdata[my_rank*todo + sampleStride*i];
	}
	void primaryDivide() {
		//主元划分
		int my_rank = omp_get_thread_num();
		int start = my_rank * todo;

		primaryDividePoint[my_rank*thread_count] = vdata + start;
		for (int i = 0;i < thread_count - 1;++i) {
			double* pos = std::lower_bound(vdata + start, vdata + start + todo, primarySamples[i]);
			while (*pos == primarySamples[i]) {
				if (pos >= vdata + start + todo) break;
				pos++;
				pos = std::lower_bound(pos, vdata + start + todo, primarySamples[i]);
			}
			primaryDividePoint[my_rank*thread_count + 1 + i] = pos;
		}
	}

	void lastSort(double* swapData) {
		//最后阶段排序
		int my_rank = omp_get_thread_num();
		std::sort(swapData + sortPoint[my_rank], swapData + sortPoint[my_rank + 1]);
	}
};

int         commSize;             		/* Number of processes   */
int         myRank;              		/* My process rank       */
double*		data = NULL;		  		/* 汇总数据				*/
double*	    subData = NULL;		 		/* 各进程内数据			*/
double*		newData = NULL;		  		/* 全局交换后数据		*/
int		    todo;						/* 各进程最初分配的数据	*/
long		totalSize;					/* 数据总个数			*/
double*		samples = NULL;				/*采样 					*/
double*		primarySamples = NULL;		/*主元 					*/
double**	primaryDividePoint = NULL;	/*主元划分点 			*/
int*		subSegmentLength = NULL;	/*全局交换长度 			*/
int*		segmentLength = NULL;
int			newSize;					/*全局交换后数据个数 	*/
OmpPsrs 	ompPsrs = OmpPsrs();		/*OpenMp排序 			*/

void selectSamples() {
	subData = ompPsrs.run(subData, todo);
	//std::sort(subData, todo);
	int sampleStride = todo / commSize;
	double* selectedSample = (double*)malloc(sizeof(double)*commSize);
	for (int i = 0;i < commSize;++i) {
		selectedSample[i] = subData[i*sampleStride];
		//printf("%d\n", selectedSample[i]);
	}
	MPI_Gather(selectedSample, commSize, MPI_DOUBLE, samples, commSize, MPI_DOUBLE, 0, MPI_COMM_WORLD);
}

void selectPrimarySamples() {
	//select primary samples
	primarySamples = (double*)malloc(sizeof(double)*(commSize - 1));
	ERO {
		samples = ompPsrs.run(samples, commSize*commSize);
		//std::sort(samples, samples + commSize*commSize);
		//for (int i = 0;i < commSize*commSize;i++) printf("%d  ", samples[i]);
		for (int i = 0;i < commSize - 1;++i) {
			primarySamples[i] = samples[(i + 1)*commSize];
			//printf("%d   ", primarySamples[i]);
		}
	}
	MPI_Bcast(primarySamples, commSize - 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
}

void primaryDivide() {
	subSegmentLength = (int*)malloc(sizeof(int) * commSize);
	segmentLength = (int*)malloc(sizeof(int)*commSize*commSize);
	primaryDividePoint = (double**)malloc(sizeof(double*) * (commSize + 1));
	primaryDividePoint[0] = subData;

	for (int i = 0;i < commSize - 1;++i) {
		double* pos = std::lower_bound(subData, subData + todo, primarySamples[i]);
		while (*pos == primarySamples[i]) {
			if (pos >= subData + todo) break;
			pos++;
			pos = std::lower_bound(pos, subData + todo, primarySamples[i]);
		}
		primaryDividePoint[i + 1] = pos;
		//printf("%d %d\n", myRank, *pos);
	}

	primaryDividePoint[commSize] = subData + todo;
	for (int i = 0;i < commSize;++i) subSegmentLength[i] = primaryDividePoint[i + 1] - primaryDividePoint[i];

	MPI_Gather(subSegmentLength, commSize, MPI_INT, segmentLength, commSize, MPI_INT, 0, MPI_COMM_WORLD);
	MPI_Barrier(MPI_COMM_WORLD);
	MPI_Bcast(segmentLength, commSize*commSize, MPI_INT, 0, MPI_COMM_WORLD);

	//if (myRank==1) for (int i = 0;i < commSize*commSize;i++) printf("%d  ", segmentLength[i]);
}

void globalSwap() {
	int* sendNum = (int*)malloc(sizeof(int)*commSize);
	int* recvNum = (int*)malloc(sizeof(int)*commSize);
	int* sendStride = (int*)malloc(sizeof(int)*commSize);
	int* recvStride = (int*)malloc(sizeof(int)*commSize);
	newSize = 0;
	for (int i = 0;i < commSize;++i) {
		sendNum[i] = segmentLength[myRank*commSize + i];
		recvNum[i] = segmentLength[i*commSize + myRank];
		newSize += recvNum[i];
	}
	sendStride[0] = 0;
	recvStride[0] = 0;
	for (int i = 1;i < commSize;++i) {
		sendStride[i] = sendStride[i - 1] + sendNum[i - 1];
		recvStride[i] = recvStride[i - 1] + recvNum[i - 1];
	}

	newData = (double*)malloc(sizeof(double)*newSize);

	MPI_Alltoallv(subData, sendNum, sendStride, MPI_DOUBLE, newData, recvNum, recvStride, MPI_DOUBLE, MPI_COMM_WORLD);
	MPI_Barrier(MPI_COMM_WORLD);
	free(subData);

	/*if (myRank == 0) {
		for (int i = 0;i < newSize;i++) printf("%d\n", newData[i]);
	}*/
}

bool subSortCheck(){
	for (int i = 0;i < newSize - 1;++i) if (newData[i] > newData[i + 1]) return false;
	return true;
}

void finalSort() {
	newData = ompPsrs.run(newData, newSize);
	//std::sort(newData, newData + newSize);
	/*
	ERO{
		data = (double*)malloc(4* totalSize);
		double* ff = (double*)malloc(4* totalSize);
		//double* ff = (double*)malloc(4* totalSize);
		if (data == NULL || ff == NULL) printf("final data malloc failed\n");
	}
	int* sendNum = (int*)malloc(sizeof(int)*(commSize));
	int* sendStride = (int*)malloc(sizeof(int)*(commSize));

	MPI_Gather(&newSize, 1, MPI_INT, sendNum, 1, MPI_INT, 0, MPI_COMM_WORLD);
	sendStride[0] = 0;
	for (int i = 1;i < commSize;++i) sendStride[i] = sendStride[i - 1] + sendNum[i - 1];

	MPI_Barrier(MPI_COMM_WORLD);
	MPI_Gatherv(newData, newSize, MPI_DOUBLE, data, sendNum, sendStride, MPI_DOUBLE, 0, MPI_COMM_WORLD);
	MPI_Barrier(MPI_COMM_WORLD);*/
	
}

bool sortCheck() {
	for (int i = 0;i < totalSize - 1;++i) if (data[i] > data[i + 1]) return false;
	return true;
}

int readSubData() {
	char pre[10];
	char pos[5] = ".txt";
	char filename[50] = "../../test4/";
	sprintf(pre, "%d", myRank + 1);
	strcat(pre, pos);
	strcat(filename, pre);

	subData = (double*)malloc(todo*sizeof(double));
	if (subData == NULL) printf("malloc failed\n");

	int handle = open(filename, O_RDWR);
	if (handle == -1)
	{
		printf("Cannot Open file %s\n", filename);
		return -1;
	}
	int readRes;
	readRes = read(handle, subData, todo*sizeof(double));
	if (!readRes) return 0;
	//printf("%f\n", subData[1]);
	//printf("%d\n", readRes);
	return 1;
}

int main(int argc, char* argv[]) {
	time_t start, stop, sm, sps, pd, gs, fs;
	time_t ts,te;
	/* Start up MPI */
	MPI_Init(NULL, NULL);

	/* Get the number of processes */
	MPI_Comm_size(MPI_COMM_WORLD, &commSize);

	/* Get my rank among all the processes */
	MPI_Comm_rank(MPI_COMM_WORLD, &myRank);

	totalSize = 1024ll*1024*1024*10;
	todo = 167772160;//1342177280 / 8;

	ERO{
		samples = (double*)malloc(sizeof(double)*commSize*commSize);
	}

	//makeData();
	readSubData();				//读取数据

	ERO printf("load complete\n");
	ERO ts = time(NULL);
	time_t subdataTime = time(NULL);

	selectSamples();			//选择样本
	ERO{
		sm = time(NULL);
		printf("selectSamples time: %lds\n", (sm - subdataTime));
		sm = time(NULL);
	}
	MPI_Barrier(MPI_COMM_WORLD);

	selectPrimarySamples();		//选择主元
	ERO{
		sps = time(NULL);
		printf("selectPrimarySamples time: %lds\n", (sps - sm));
		sps = time(NULL);
	}

	primaryDivide();			//主元划分
	ERO{
		pd = time(NULL);
		printf("primaryDivide time: %lds\n", (pd - sps));
		pd = time(NULL);
	}

	globalSwap();				//全局交换
	ERO{
		gs = time(NULL);
		printf("globalSwap time: %lds\n", (gs - pd));
		gs = time(NULL);
	}

	finalSort();				//子数组排序
	ERO{
		fs = time(NULL);
		printf("finalSort time: %lds\n", (fs - gs));
	}

	MPI_Barrier(MPI_COMM_WORLD);
	ERO te = time(NULL);
	//计算时间
	ERO printf("time : %lds\n", te - ts);
	if (!subSortCheck()) printf("subSort failed\n");
	free(newData);
	ERO{
		//free(data);
	}

	MPI_Finalize();

	return 0;
}
MPI + OpenMP实现快速排序
谢谢๑‾᷅^‾᷅๑的博客
10-31 2518
题目 结合高性能并行计算领域算例，使用MPI + OpenMP并行化编写代码，并撰写报告，测试并行效率。 方法 定义快速排序quickSort函数，定义排序总数NUM； 生成大小为size * calculateSize的二维逆序数组，其中使用MPI_Comm_size获取size，size * calculateSize = NUM； MPI_Comm_rank获取进程ID，通过通信函数MPI_Scatter将每个子矩阵发送到每个子进程，然后每个子进程通过quickSort函数进行快速排序，使用Open
OpenMP实现计算pi值和PSRS排序并行计算实验
05-08
并行计算课程实验代码，c语言写的，在MacOS系统下的openmp的pi值计算和PSRS的实现，注释清晰，且PSRS处理了不整除的情况。懒得编译可使用我提供的run.sh脚本。加上待编译的文件作为参数即可。
使用MPI实现的PSRS并行排序算法
06-03
使用MPI计算的完整的PSRS（并行排序(parallel sorting by regular sampling)）代码。并行计算课实验所用代码。
PSRS均匀划分排序算法，mpi并行程序
01-07
PSRS均匀划分排序算法，mpi并行程序
MPI和openMP并行计算-冒泡排序
10-20
MPI和openMP并行计算-冒泡排序
MPI & OpenMP
笨鸟不爱飞
08-02 1233
MPI（Message Passing Interface，消息传递接口，MPI是一个标准，有不同的具体实现，LAM/MPI和MPICH是目前使用最为广泛的免费MPI实现版本，它们都支持MPI 1标准的全部内容，同时还支持部分MPI 2标准）是多主机联网协作进行并行计算的工具，当然也可以用于单主机上多核/多CPU的并行计算，不过效率低。它能协调多台主机间的并行计算，因此并行规模上的可伸缩性很强，能
mpi psrs算法c语言,基于 MPI 的 PSRS 并行排序算法的实现
weixin_42213784的博客
05-24 486
基于 MPI 的 PSRS 并行排序算法的实现View348Download20Embed Size (px)344 x 292429 x 357514 x 422599 x 487DESCRIPTION基于 MPI 的 PSRS 并行排序算法的实现. 09 国土王信. 什么是并行计算. 传统上，一般的软件设计都是串行式计...
精选资源
实现（串行，openmp、mpi、openmp+mpi）快速排序算法，并作出时间对比图
12-26
主要采用快速排序实现（串行，openmp、mpi、openmp+mpi）排序算法，所需环境为VS2019+openmp+mpi，cmd命令 （1）完成了CPU串行程序和三种并行程序在各种规模的运行，并作出时间对比图 （2）完成了串行，openmp使用...
实验报告- 在华为鲲鹏服务器上的 OpenMP+MPI矩阵LU分解
07-05
【OpenMP+MPI矩阵LU分解】实验报告主要探讨了如何在华为鲲鹏服务器上利用OpenMP和MPI并行计算技术对矩阵进行LU分解，以高效解决线性方程组的问题。矩阵LU分解是线性代数中的一个重要概念，它将线性方程组的求解转化...
分别使用OpenMP、MPI、OpenMP+MPI混合编程实现并行矩阵乘法
12-26
### 使用 OpenMP 实现并行矩阵乘法 对于多线程环境下的矩阵乘法，可以采用 OpenMP 来简化开发过程。通过编译器指令来指示哪些部分应该被多个线程执行。 ```cpp #include #include void openmp_matrix_multiply...
MPI实现的快速排序
12-15
用MPI实现的快速排序，提高快速排序的效率
快速排序的并行算法
05-17
快速排序的并行实现，提高效率。快速排序算法并行化的一个简单思想是，对每次划分过后所得到的两个序列分别使用两个处理器完成递归排序。
多种排序的并行算法（具体）
10-18
本文主要介绍了枚举排序、快速排序、PSRS排序算法以及它们的MPI编程实现。排序是数据处理中经常使用的一种重要运算，如何进行排序，特别是如何进行高效的排序，是计算机应用中的重要课题。排序的对象一般是一组记录组成的文件，而记录则是由若干数据项组成，其中的一项可用来标志一个记录，称为关键字项，该数据项的值称为关键字。 所谓排序，就是要整理文件中的记录，使得它按关键字递增（或递减）的次序排列起来。
基于MPI的PSRS算法的实现
04-19
基于MPI的PSRS排序算法的实现，使用C语言在VS2005下编译通过，在利用MPI搭建的并行平台下运行成功。希望对大家有些参考作用。
OpenMP+MPI
最新发布
01-01
### 结合使用 OpenMP 和 MPI 的混合模式并行编程 在高性能计算领域，结合使用 OpenMP 和 MPI 可以充分利用多核处理器的优势以及分布式内存系统的资源。这种混合编程模型能够有效提高程序性能和可扩展性。 #### ...
并行编程方式：OpenMP + MPI +Mapreduce
朝着梦想 渐行前进
12-16 3423
http://redtreewood.blogspot.com/2009/10/openmp-mpi-mapreduce.html OpenMP: OpenMp是线程级别的，共享是存储，只适应用于共享总线与内存，单一操作系统映像的SMP机器和DSM机器。可扩展性比较差，对机器的要求比较高。一般双核的机器（很多CPU共享内存条）适合用OpenMP，可以提高一定的运行速度。这个在科学计
OpenMP: OpenMP和MPI是并行编程
Augusdi的专栏
04-15 3455
OpenMP和MPI是并行编程的两个手段，对比如下：1.    OpenMP:线程级（并行粒度）；共享存储；隐式（数据分配方式）；可扩展性差； 2.    MPI：进程级；分布式存储；显式；可扩展性好。3.    OpenMP采用共享存储，意味着它只适应于SMP、DSM机器，不适合于集群。MPI虽适合于各种机器，但它的编程模型复杂：需要分析及划分应用程序问题，并将问题映射到分布式进程集合；需要解决
并行计算OpenMP与MPI环境搭建
mc_故事与你的博客
04-01 4114
目前公开文献可查到比较早提出的定义是Gottlieb等人在1989年《高性能计算》一书中给出的。Gottlieb等认为：并行计算是一种计算类型，其中许多计算或计算过程的执行是同时执行的。并行计算的目的是加快计算速度。我国学者张林波在其编写的教材《并行计算导论》中对并行计算进行了描述性定义：并行计算（parallel computing）是指，在并行机上，将一个应用分解成多个子任务，分配给不同的处理器，各个处理器之间相互协同，并行地执行子任务，从而达到加速求解速度，或者求解应用问题规模的目的。
OpenMP + MPI 编程 （一）Introduction
叶子心情你不懂
11-13 323
Yun (Helen) He and Chris Ding, Lawrence Berkeley National Laboratory, June 24, 2004: Hybrid OpenMP and MPI Programming and Tuning (NUG2004). Texas Advanced Computing Center: Stampede2 User Guide: Hybrid Model. Message Passing Interface Forum: MPI-2: M.
使用OpenMP+MPI混合编程实现矩阵并行乘法
12-26
### 使用 OpenMP 和 MPI 实现矩阵并行乘法 为了提高大规模矩阵运算效率，可以采用 OpenMP 和 MPI 混合编程模式来充分利用多核处理器资源以及分布式内存架构的优势。下面展示了一个简单的 C++ 示例代码，该代码展示了如何通过结合这两种技术实现高效的矩阵相乘操作。 #### 1. 初始化环境设置 在开始之前，确保已经安装了支持 OpenMP 的编译器（如 GCC 或 Intel 编译器），并且配置好了 MPI 开发库。 #### 2. 安装依赖项 如果尚未安装必要的工具链，在 Linux 上可以通过包管理器快速获取： ```bash sudo apt-get install mpich libomp-dev gcc g++ ``` #### 3. 示例代码：OpenMP + MPI 矩阵乘法 ```cpp #include <mpi.h> #include <omp.h> #include <iostream> #define N 1000 // Matrix size, can be adjusted as needed. int main(int argc, char *argv[]) { int rank, size; double start_time, end_time; /* Initialize the MPI environment */ MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &size); if (N % size != 0) { std::cerr << "Matrix dimension must be divisible by number of processes." << std::endl; MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE); } const int local_n = N / size; // Each process handles a submatrix. double A[N][N], B[N][N], C[N][N]; // Global matrices on root node only // Only initialize matrix data at Rank 0 and broadcast it to all nodes. if (!rank) { for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j){ A[i][j] = static_cast<double>(rand()) / RAND_MAX; B[i][j] = static_cast<double>(rand()) / RAND_MAX; } start_time = MPI_Wtime(); } // Broadcast global matrix A from master to slaves using MPI_Bcast function[^2]. MPI_Bcast(A, N*N, MPI_DOUBLE, 0, MPI_COMM_WORLD); // Scatter rows of matrix B across different ranks with MPI_Scatterv operation. double* recvcounts = new double[size]; double* displs = new double[size]; for (int p=0;p<size;++p){ recvcounts[p]=local_n*N; displs[p]=(p)*recvcounts[p]; } double b_local[local_n][N]; MPI_Scatterv(B, recvcounts, displs, MPI_DOUBLE, &(b_local[0][0]), local_n*N, MPI_DOUBLE, 0, MPI_COMM_WORLD); delete[] recvcounts; delete[] displs; // Allocate space locally for result matrix c_local. double c_local[local_n][N]={}; #pragma omp parallel num_threads(8) shared(c_local,A,b_local,N,local_n) { #pragma omp for schedule(static) for (int row = 0; row < local_n; ++row) { for (int col = 0; col < N; ++col) { double sum = 0.; for (int k = 0; k < N; ++k) sum += A[row+k*local_n][col]*b_local[row][k]; c_local[row][col] = sum; } } } // Gather results back into full matrix C held by Process Zero via MPI_Gatherv call. if(!rank){ double* sendcounts=new double[size]; double* sdispls=new double[size]; for (int p=0;p<size;++p){ sendcounts[p]=local_n*N; sdispls[p]=(p)*sendcounts[p]; } MPI_Gatherv(&(c_local[0][0]), local_n*N, MPI_DOUBLE,&C[0][0], sendcounts,sdispls,MPI_DOUBLE,0,MPI_COMM_WORLD); delete[] sendcounts; delete[] sdispls; }else{ MPI_Gatherv(&(c_local[0][0]), local_n*N, MPI_DOUBLE,C, NULL,NULL ,MPI_DOUBLE,0,MPI_COMM_WORLD); } if (!rank) { end_time=MPI_Wtime()-start_time; printf("Time taken: %.6f seconds\n",end_time); } MPI_Finalize(); return 0; } ``` 此程序首先初始化 MPI 进程组，并分配给每个进程一部分工作负载；接着利用 `MPI_Bcast` 将整个输入矩阵广播到所有节点上，再用 `MPI_Scatterv` 方法分发子矩阵片段至各个处理单元。之后借助 OpenMP 对局部区域内的计算任务实施多线程加速。最后收集各部分的结果形成完整的输出矩阵并通过 `MPI_Gatherv` 返回给主控端。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值