使用一个一维数组进行矩阵转置以及其并行化

最新推荐文章于 2023-08-02 16:09:02 发布
最新推荐文章于 2023-08-02 16:09:02 发布
阅读量530 收藏
点赞数
分类专栏： c cuda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alfafar/article/details/115365102
版权
c 同时被 2 个专栏收录
9 篇文章 0 订阅
订阅专栏
cuda
3 篇文章 0 订阅
订阅专栏

直接上代码，思路全在纸上，写两下找规律就能写了

#include<time.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include<stdlib.h>
#include <stdio.h>
#define maxsize 2000
#define INDEX(i, j, ldy)  ((i)* (ldy)+(j))

__global__ void Turn(int* data, int n ){
	int i = threadIdx.x + blockIdx.x * blockDim.x;
	for (int j = i + 1; j < n - i; j++) {
		int temp = 0;
		temp = data[INDEX(i, j, maxsize)];//保存了左上角的第一个点
		data[INDEX(i, j, maxsize)] = data[INDEX(j, maxsize - 1 - i, maxsize)];//左上角的点=右上角的点
		data[INDEX(j, maxsize - 1 - i, maxsize)] = data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)];//右上角的点=右下角的点
		data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)] = data[INDEX(maxsize - 1 - j, i, maxsize)];//右下角的点=左下角的点
		data[INDEX(maxsize - 1 - j, i, maxsize)] = temp;//左下角的点=左上角的点

		//向右旋转：
		//i!j=n-1-j !i
		//n-1-j!i=n-1-i!n-1-j
		//n-1-i!n-1-j=n-1-i
		//j!n-1-i=temp
	}
}
void Print(int* data) {
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			printf(" %d", data[INDEX(i, j, maxsize)]);

		}
		printf("%\n");
	}
	printf("%\n");
	printf("%\n");
}
int* CPU(int* data, int n, int x) {
	//利用循环判断每次该旋转几个数，像剥洋葱一样从外到里一层一层操作
	//每次都旋转一层，每层从i+1开始到n-i-1为止
	//每次旋转四个对角的数
	for (int i = 0; i < n / 2; i++) {
		for (int j = i + 1; j < n - i; j++) {
			int temp = 0;
			temp = data[INDEX(i, j, maxsize)];//保存了左上角的第一个点
			data[INDEX(i, j, maxsize)] = data[INDEX(j, maxsize - 1 - i, maxsize)];//左上角的点=右上角的点
			data[INDEX(j, maxsize - 1 - i, maxsize)] = data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)];//右上角的点=右下角的点
			data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)] = data[INDEX(maxsize - 1 - j, i, maxsize)];//右下角的点=左下角的点
			data[INDEX(maxsize - 1 - j, i, maxsize)] = temp;//左下角的点=左上角的点

			//向右旋转：
			//i!j=n-1-j !i
			//n-1-j!i=n-1-i!n-1-j
			//n-1-i!n-1-j=n-1-i
			//j!n-1-i=temp
		}
	}
	//Print(data);
	return data;
}
int Check(int* a, int* b) {
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			if (a[INDEX(i, j, maxsize)] != b[INDEX(i, j, maxsize)])
				return 1;
		}
	}
	return 0;
}
void GPU(int* data) {


	
	printf("\n	GPU code is running...\n");
	int n = maxsize;
	int* d_data;
	cudaMalloc((void**)&d_data, sizeof(int) * maxsize * maxsize);
	cudaMemcpy(d_data, data, sizeof(int) * maxsize * maxsize, cudaMemcpyHostToDevice);
	int block_num = maxsize/2;
	int grid_num = (maxsize + block_num - 1) / block_num;


	clock_t start1, end1;
	start1 = clock();
	Turn << < grid_num, block_num >> > (d_data, n);
	end1 = clock();
	float time1 = (float)(end1 - start1) / CLOCKS_PER_SEC;
	printf("	The tim GPU used is:%lf\n", time1);
	cudaMemcpy(data,d_data, sizeof(int) * maxsize * maxsize, cudaMemcpyDeviceToHost);

	printf("	GPU program is end...\n\n");
	cudaFree(d_data);
}
int main() {

	int* a;
	cudaMallocHost((void**)&a, sizeof(int) * maxsize * maxsize);
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			a[INDEX(i, j, maxsize)] = INDEX(i, j, maxsize);
		}
	}
	int* b;
	b = (int*)malloc(sizeof(int) * maxsize * maxsize);
	cudaMemcpy(b, a, sizeof(int) * maxsize * maxsize, cudaMemcpyHostToHost);

	//printf("数组创建成功：\n");
	//Print(a);


	printf("\n	CPU code is running...\n");
	clock_t start1, end1;
	start1 = clock();
	a = CPU(a, maxsize, 0);
	end1 = clock();
	float time1 = (float)(end1 - start1) / CLOCKS_PER_SEC;
	printf("	The tim CPU used is:%lf\n",time1);
	printf("	CPU program is end...\n\n");

	//printf("数组b：\n");
	//Print(b);
	//printf("数组a旋转后：\n");
	//Print(a);

	GPU(b);
	if (Check(a, b)) {
		printf("\nthe GPU's answer is wrong!\n");
	}
	else {
		printf("	The Answer is Right!\n");
	}
	free(b);
	cudaFree(a);

	return 0;
}

目前看起来并行化的加速比性能很高，但是我把最大数参数maxsize调到2000以上的时候，答案就开始错误了，不知道为什么，后面解决后再更新，欢迎大家一起探讨。

4月6日更新

通过对每一个过程采用
cudaStatus != cudaSuccess的方式，一步步排查出了问题，发现原来是我的最大线程数设置了为最大数/2，而我电脑支持的最大线程数却只有1024，超过之后就会报参数错误：invalid configuration argument

修改后的代码已经可以正确运行并且没有出错了。

#include<time.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include<stdlib.h>
#include <stdio.h>
#define maxsize 10000
#define INDEX(i, j, ldy)  ((i)* (ldy)+(j))

/*
小写一个思路：
写4个GPU函数，每一个对应矩阵的1/4的数量
但是我是用一维数组来保存的展开的二维矩阵，所以需要设计如何保存这1/4

*/
__global__ void Turn(int* data, int n ){
	int i = threadIdx.x + blockIdx.x * blockDim.x;
	for (int j = i + 1; j < n - i; j++) {
		int temp = 0;
		temp = data[INDEX(i, j, maxsize)];//保存了左上角的第一个点
		data[INDEX(i, j, maxsize)] = data[INDEX(j, maxsize - 1 - i, maxsize)];//左上角的点=右上角的点
		data[INDEX(j, maxsize - 1 - i, maxsize)] = data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)];//右上角的点=右下角的点
		data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)] = data[INDEX(maxsize - 1 - j, i, maxsize)];//右下角的点=左下角的点
		data[INDEX(maxsize - 1 - j, i, maxsize)] = temp;//左下角的点=左上角的点

		//向右旋转：
		//i!j=n-1-j !i
		//n-1-j!i=n-1-i!n-1-j
		//n-1-i!n-1-j=n-1-i
		//j!n-1-i=temp
	}
}
void Print(int* data) {
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			printf(" %d", data[INDEX(i, j, maxsize)]);

		}
		printf("%\n");
	}
	printf("%\n");
	printf("%\n");
}
int* CPU(int* data, int n, int x) {
	//利用循环判断每次该旋转几个数，像剥洋葱一样从外到里一层一层操作
	//每次都旋转一层，每层从i+1开始到n-i-1为止
	//每次旋转四个对角的数
	for (int i = 0; i < n / 2; i++) {
		for (int j = i + 1; j < n - i; j++) {
			int temp = 0;
			temp = data[INDEX(i, j, maxsize)];//保存了左上角的第一个点
			data[INDEX(i, j, maxsize)] = data[INDEX(j, maxsize - 1 - i, maxsize)];//左上角的点=右上角的点
			data[INDEX(j, maxsize - 1 - i, maxsize)] = data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)];//右上角的点=右下角的点
			data[INDEX(maxsize - 1 - i, maxsize - 1 - j, maxsize)] = data[INDEX(maxsize - 1 - j, i, maxsize)];//右下角的点=左下角的点
			data[INDEX(maxsize - 1 - j, i, maxsize)] = temp;//左下角的点=左上角的点

			//向右旋转：
			//i!j=n-1-j !i
			//n-1-j!i=n-1-i!n-1-j
			//n-1-i!n-1-j=n-1-i
			//j!n-1-i=temp
		}
	}
	//Print(data);
	return data;
}
int Check(int* a, int* b) {
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			if (a[INDEX(i, j, maxsize)] != b[INDEX(i, j, maxsize)])
				return 1;
		}
	}
	return 0;
}
cudaError_t GPU(int* data) {
	printf("\n	GPU code is running...\n");
	int n = maxsize;
	int* d_data;
	cudaError_t cudaStatus;
	cudaStatus =cudaMalloc((void**)&d_data, sizeof(int) * maxsize * maxsize);
	if (cudaStatus != cudaSuccess) {
		printf("device memory malloc allocation failed"); 
		return cudaStatus;
	}
	cudaStatus = cudaMemcpy(d_data, data, sizeof(int) * maxsize * maxsize, cudaMemcpyHostToDevice);
	if (cudaStatus != cudaSuccess) {
		printf("device memory allocation failed");
		return cudaStatus;
	}
	
	int block_num = 1024;
	int grid_num = (maxsize + block_num - 1) / block_num;

	clock_t start1, end1;
	start1 = clock();
	Turn << < grid_num, block_num >> > (d_data, n);
	end1 = clock();
	cudaStatus = cudaGetLastError();
		if (cudaStatus != cudaSuccess) 
		{
			fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
			return cudaStatus;
		}
		cudaStatus = cudaDeviceSynchronize();
		 if (cudaStatus != cudaSuccess) {
			 printf("Synchronize failed!\n");
			 return cudaStatus;
		 }

	float time1 = (float)(end1 - start1) / CLOCKS_PER_SEC;
	printf("	The tim GPU used is:%lf\n", time1);
	cudaStatus = cudaMemcpy(data, d_data, sizeof(int) * maxsize * maxsize, cudaMemcpyDeviceToHost);
	if (cudaStatus != cudaSuccess) {
		printf("Device to Host memory  failed");
		return cudaStatus;
	}
	

	printf("	GPU program is end...\n\n");
	cudaFree(d_data);
	return cudaSuccess;
}
int main(void ) {

	int* a;
	cudaMallocHost((void**)&a, sizeof(int) * maxsize * maxsize);
	for (int i = 0; i < maxsize; i++)
	{
		for (int j = 0; j < maxsize; j++)
		{
			a[INDEX(i, j, maxsize)] = INDEX(i, j, maxsize);
		}
	}
	int* b;
	b = (int*)malloc(sizeof(int) * maxsize * maxsize);
	cudaMemcpy(b, a, sizeof(int) * maxsize * maxsize, cudaMemcpyHostToHost);

	//printf("数组创建成功：\n");
	//Print(a);
	printf("\n	CPU code is running...\n");
	clock_t start1, end1;
	start1 = clock();
	a = CPU(a, maxsize, 0);
	end1 = clock();
	float time1 = (float)(end1 - start1) / CLOCKS_PER_SEC;

	printf("	The tim CPU used is:%lf\n",time1);
	printf("	CPU program is end...\n\n");

	//printf("数组b：\n");
	//Print(b);
	//printf("数组a旋转后：\n");
	//Print(a);
	cudaError_t cudaStatus;
	cudaStatus=GPU(b);
	if (cudaStatus != cudaSuccess) {
		printf("GPU failed!");
		return 1;
	}
	if (Check(a, b)) {
		printf("\nthe GPU's answer is wrong!\n");
	}
	else {
		printf("	The Answer is Right!\n");
	}
	free(b);
	cudaFree(a);

	return 0;
}
Alfafar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用c语言实现矩阵的转置算法,C++实现矩阵原地转置算法
weixin_28607671的博客
05-23 2223
本文实例描述了C++实现矩阵原地转置算法，是一个非常经典的算法，相信对于学习C++算法的朋友有很大的帮助。具体如下：一、问题描述微软面试题：将一个MxN的矩阵存储在一个一维数组中，编程实现矩阵的转置。要求：空间复杂度为O(1)二、思路分析下面以一个4x2的矩阵A={1,2,3,4,5,6,7,8}进行分析，转置过程如下图：图中右下角的红色数字表示在一维数组中的下标。矩阵的转置其实就是数组中元素的移...
数据结构考点之一维数组实现矩阵转置算法
guangod的博客
07-10 1776
算法阅读题解题问题分析第一问第二问 问题 阅读下列程序 void f30(int A[]，int n) {　 int i,j,m; 　　for(i=1；i<n；i++) 　　　for(j=0；j<i；j++) 　　　　{ 　 m=A[i*n+j]； 　　　　　// A[i*n+j]与A[j*n+i]值交换 　　　　　　 A[i*n+j]=A[j*n+i]； 　　　　　　 A[j*n+i]=m； 　　　　} } 回答下列问题： (1)已知矩阵 B=(123456789)B=
矩阵原地转置
dbbaq24022的专栏
06-06 339
一，问题描述 微软面试题：将一个MxN的矩阵存储在一个一维数组中，编程实现矩阵的转置。 要求：空间复杂度为O(1) 二，思路分析 下面以一个4x2的矩阵A={1,2,3,4,5,6,7,8}进行分析，转置过程如下图： 图中右下角的红色数字表示在一维数组中的下标。矩阵的转置其实就是数组中元素的移动，具体的移动过程如下图： ...
C++一维数组实现矩阵的转置与乘法
flying_saker的博客
10-24 9755
矩阵的构建策略 为保证多数据的兼容性，以及广泛性。本篇笔者使用C++模板进行书写。同时变量定义使用了“（）”进行初始化操作。 首先是构造可变长数组的策略：使用堆内存，笔者未使用vector。当然vector应当更方便操作 int n, m; cin &gt;&gt; n &gt;&gt; m; int *a = new int[n*m]; //使用此方法进行一维可变长数组的构造 int ...
24、【数组】旋转矩阵（C++版）
STAR GAME
01-10 8189
题目描述 题目分析 目标矩阵的行列数相同，均为n。则此题是n×n型矩阵的旋转，重点把握好旋转前后行、列索引编号的变化。通过对旋转前后的索引编号进行分析找出，旋转后的变化关系即可。 解法一：辅助数组 当旋转第一行时， (0,0) => (0,3) (0,1) => (1,3) (0,2) => (2,3) (0,3) => (3,3) 当旋转第二行时， (1,0) => (0,2) (1,1) => (1,2) (1,2) => (2,2) (1,3) =&gt
LeetCode练习——数组（旋转数组）
strivequeen的博客
05-17 89
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。 进阶： 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？ 示例 1: 输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4] 解释: 向右旋转 1 步: [7,1,2,3,4,5,6] 向右旋转 2 步: [6,7,1,2,3,4,5] 向右旋转 3 步: [5,6,7,1,2,3,4] 示例 2:.
PHP简单实现二维数组的矩阵转置操作示例
12-20
本文实例讲述了PHP简单实现二维数组的矩阵转置操作。分享给大家供大家参考，具体如下： <?php $arr1 = array( array(1,2,3), array(4,5,6), array(6,7,8), array('a','b','c') ); echo '软件开发网测试...
python矩阵转换为一维数组的实例
09-20
今天小编就为大家分享一篇python矩阵转换为一维数组的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C++两个一维数组相加求和
10-09
1、本文详细描述了C++语言两个一维数组相加求和的方法。 2、通过详细示例，让读者更直观地阅读，更清晰的理解。 3、示例代码可直接复制，编译后可直接运行。 4、根据示例以及运行结果，让读者加强记忆及理解。
LabVIEW创建一维数组
01-19
一维数组是基本的数组，多维数组是在一维数组的基础上创建的。一维数组的创建过程如下。 　（1）创建数组框架。在前面板窗口控件选板中选择控件“新式→数组、矩阵与簇→数组，置于...如图3所示即为创建一个数值型控件
C语言——矩阵转置
王元笙
12-01 1万+
C语言更加灵活的矩阵转置操作
多维矩阵/数组变成一维数组
Mr_Cat123的博客
01-20 4850
在这篇文章中实际上提及了4种方法4种方法 但常用了我写两种： 1 使用reshape, 表示重新改变结构 上面我生成了一个22的2维数组，我想将他们变成1维数组，使用reshape(-1),(括号有几个数表示几维，如reshape(1,1,1)表示三维)，最后reshape是不改变原来的值的。这里-1表示不限定行数。注意reshape(-1,1)是二维，表示不论多少行弄成一列，实际上就是41...
C语言 矩阵转置
2301_76445610的博客
08-02 2002
而在C语言中，说到矩阵，我们第一时间想到的应该就二维数组的矩阵特性，所以，对于C语言的矩阵置换就是关于二维数组中行和列的置换。矩阵置换，矩阵置换的本质是长和宽的相互转化，举例，一个长3宽2的长方形，在进行矩阵置换后，变换成为了一个长2宽3的长方形。
一维数组矩阵转置c语言,【C语言程序设计】利用数组解决线性代数中的矩阵转置问题！...
weixin_42298382的博客
05-25 1056
本实例是利用数组解决线性代数中的矩阵转置问题。设有一矩阵为 m×n 阶(即 m 行 n 列)，第 i 行 j 列的元素是 a(i,j)，需要将该矩阵转置为 n×m 阶的矩阵，使其中元素满足 b(j,i)=a(i,j)。算法思想由数学知识可知，将第一个矩阵的所有元素绕着一条从第一行第一列出发的右下角 45° 的射线做镜面反转，即可得到该矩阵的转置。程序代码#includeint main(){int...
c++矩阵转置_手把手的Numpy教程，从此数据处理不再慌——reshape、转置篇
weixin_39953236的博客
11-20 652
今天这篇是numpy专题的第四篇文章，numpy中的数组重塑与三元表达式。首先我们来看数组重塑，所谓的重塑本质上就是改变数组的shape。在保证数组当中所有元素不变的前提下，变更数组形状的操作。比如常用的操作主要有两个，一个是转置，另外一个是reshape。转置与reshape转置操作很简单，它对应线性代数当中的转置矩阵这个概念，也就是说它的功能就是将一个矩阵进行转置。转置矩阵的定义是将一个矩阵的...
python 一维数组转置_numpy.transpose()实现数组的转置例子
weixin_39869791的博客
02-09 5131
说到转置操作，顺便提及矩阵与数组的区别：矩阵：数学里的概念，其元素只能是数值，这也是区别于数组的根本所在数组：计算机中的概念，代表一种数据组织、存储方式，其元素可以是数字、也可以是字符数组的转置操作，是借鉴了线性代数中矩阵的转置操作。将行与列对调，即第一行变成第一列…..或第一列变成第一行…..的操作即使转置操作。1. 多维数组的转置import numpy as nptest = np.arra...
一维数组的转置
m0_53110330的博客
12-08 2501
一个可能比较常见的解法。 #include<stdio.h> int main() { int a[200]; int n, i, temp; printf("input a number:"); scanf("%d", &n); for (i = 0;i < n;i++) { scanf("%d", &a[i]); } for (i = 0;i < n / 2;i++) { temp = a[i]; a[i] = a[n - 1 - i
Numpy一维array转置
热门推荐
积沙成塔
06-23 3万+
参考：https://www.cnblogs.com/cymwill/p/8358866.html分析Numpy相关的转置函数有T、transpose等。使一维数组转置可以使用reshape实现。实现例子import numpy as np a = np.array([1,2,3,4,5]) print(a) print(a.T) print(a.transpose()) prin...
numpy 一维矩阵转置问题
thompson的博客
01-14 2057
##Numpy 一位矩阵转置问题 numpy中，我们如果直接对一维行矩阵转置，会出现问题 这时，可以采用expand_dims import numpy as np d=np.zeros((1,9)) d.shape d=np.expand_dims(d,axis=0) d.shape d.T d.transpose() expand_dims后的shape是(9,1),a.T就没有问题了 ...
c语言 一维数组 矩阵转置
最新发布
11-21
以下是两个C语言一维数组矩阵转置的例子： 引用: ```c #include #include int main(){ int a[2][3]={{1,2,3},{4,5,6}}; int b[3][2]; int i,j; printf("原数组为: \n"); for(i=0;i;i++){ for(j=0;j;j++){ ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值