Cache Lab：Part B（52.6/53分）【矩阵转置的分块算法】

已于 2024-02-01 20:08:38 修改
阅读量958 收藏 14
点赞数 22
分类专栏： 《CS:APP》的实验 文章标签： 处理器体系结构 csapp 高速缓存存储器 分块算法 矩阵转置
于 2024-02-01 20:07:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45339670/article/details/135981296
版权

目录

任务描述

32 × 32

baseline

try1：给对角线上的块再次细分块

try2：对角块依次错位

成功：对角块两两交换 

成功：其他方法

64 × 64 

baseline

对角线优化+普通块转置顺序调整（7.6/8分）

61 × 67

成功：bsize=16*16

测试

任务描述

要求在trans.c中编写一个转置函数，从而导致尽可能少的miss。缓存的参数是 (s = 5, E = 1, b = 5)。三种测试用例的矩阵大小分别为：
        • 32 × 32 (M = 32, N = 32)
        • 64 × 64 (M = 64, N = 64)
        • 61 × 67 (M = 61, N = 67)

规定：仅使用12个局部变量，不能使用递归，不能修改A数组（可任意修改B数组），不允许使用malloc。

提示：你的代码只需要针对这三种情况是正确的，并且你可以针对这三种情况进行专门优化。特别是，你的函数完全可以显式检查输入大小并实现针对每种情况优化的单独代码。

32 × 32

baseline

下图是32*32数组的分块情况，每一个小格代表一个block（由前提条件b=5，得出一个块是32字节，由于是int数组，所以一个block能存8个元素）

上面是16个大块。

转置时依次扫描大块1~16，将块内元素转置后放在数组B对应的位置。可以发现，除了对角块，其余都是没有冲突未命中的。

int i, j, k, q, tmp;
if (M == 32 && N == 32)
{
	for (k = 0; k < 4; k++)
	{
		for (q = 0; q < 4; q++)
		{
			for (i = 0; i < 8; i++)
			{
				for (j = 0; j < 8; j++)
				{
					tmp = A[k * 8 + i][q * 8 + j];
					B[q * 8 + j][k * 8 + i] = tmp;
				}
			}
		}
	}
}

 由于PartA我们已经实现了模拟器了，所以miss的值肯定是能手算出来的。我们先大概算一下。

对于图上未着色的12个大块，12*16=192；对于对角线上的4个大块（着色的），4*（10+4+4+4+4+4+4+3）=144；故大约是192+144=336。

测试程序算的是344，大差不差。但仍需优化。 修改思路就是对于对角线进行进一步优化。

try1：给对角线上的块再次细分块

本来一个大块是8*8的，对于对角线，再一分为四，变为4*4。

还是先来预算一下结果：12个大块跟baseline一样是192；对角线上8个4*4块：8*（6+4+4+3）=138；其余8个4*4块：8*8=64；总计192+138+64=392。

测试程序计的数也是392，这种方法更差了。

int i, j, k, q, i2, j2, k2, q2, tmp;
if (M == 32 && N == 32)
{
	for (k = 0; k < 4; k++)
	{
		for (q = 0; q < 4; q++)
		{
			if (k == q)
			{
				for (k2 = 0; k2 < 2; k2++)
				{
					for (q2 = 0; q2 < 2; q2++)
					{
						for (i2 = 0; i2 < 4; i2++)
						{
							for (j2 = 0; j2 < 4; j2++)
							{
								tmp = A[k * 8 + k2 * 4 + i2][q * 8 + q2 * 4 + j2];
								B[q * 8 + q2 * 4 + j2][k * 8 + k2 * 4 + i2] = tmp;
							}
						}

					}
				}
			}
			else
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 + j][k * 8 + i] = tmp;
					}
				}
			}

		}
	}
}

try2：对角块依次错位

具体来说，转置完的1号大块存在6号大块，6号存在11号，11号存在16号。16号进行普通转置。

int i, j, k, q, tmp;
if (M == 32 && N == 32)
{
	for (k = 0; k < 4; k++)
	{
		for (q = 0; q < 4; q++)
		{
			if (k == q && k != 3)
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 + 8 + j][k * 8 + 8 + i] = tmp;
					}
				}
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = B[k * 8 + i + 8][q * 8 + j + 8];
						B[k * 8 + i][q * 8 + j] = tmp;
					}
				}
			}
			else
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 + j][k * 8 + i] = tmp;
					}
				}
			}
		}
	}
}

现象：变好，m=305（只差一点点） 

成功：对角块两两交换 

具体来说，A的1号转置完成后存到B的6号，A的6号转置完存到B的1号去。然后，B的1号和6号交换。11号和16号同理。

现象：m=276，成功。

int i, j, k, q, tmp;
if (M == 32 && N == 32)
{
	for (k = 0; k < 4; k++)
	{
		for (q = 0; q < 4; q++)
		{
			if (k == q && k % 2 == 0)
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 + 8 + j][k * 8 + 8 + i] = tmp;
					}
				}
			}
			else if (k == q && k % 2 == 1)
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 - 8 + j][k * 8 - 8 + i] = tmp;
					}
				}
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = B[k * 8 + i][q * 8 + j];
						B[k * 8 + i][q * 8 + j] = B[k * 8 - 8 + i][q * 8 - 8 + j];
						B[k * 8 - 8 + i][q * 8 - 8 + j] = tmp;
					}
				}
			}
			else
			{
				for (i = 0; i < 8; i++)
				{
					for (j = 0; j < 8; j++)
					{
						tmp = A[k * 8 + i][q * 8 + j];
						B[q * 8 + j][k * 8 + i] = tmp;
					}
				}
			}
		}
	}
}

成功：其他方法

以上思路是我独立想出的。看了其他人的解法，在此补充一下：

对角线处发生的较多conflict miss的原因是，A和B相同大块之间是占有相同索引位置的cache的。如果先把A的对角线上的大块原封不动的挪到对应位置的B大块，然后让B大块原地转置，原地转置是不存在conflict miss的。

问题就变成了怎么实现“把A的对角线上的大块原封不动的挪到对应位置的B大块”，因为同时访问AB的对应位置就会发生conflict miss。

其实示例程序的tmp变量是个提示。可以多来几个局部变量，当做一个临时数组。也就是将循环最内层完全展开。

这种方法的代码请见 https://zhuanlan.zhihu.com/p/410662053

64 × 64 

baseline

现象：m=1892（满分1300）

对角线优化+普通块转置顺序调整（7.6/8分）

对角线转置方法：

普通块：

	if (M == 64 && N == 64)
	{
		//k q 将64*64棋盘分为64个8*8的小格
		for (k = 0; k < 8; k++)
		{
			for (q = 0; q < 8; q++)
			{
				//处理对角线
				if (k == q)
				{
					int bias = 8;
					if (k % 2 == 1) bias = -8;
					for (i = 0; i < 4; i++)
						for (j = 0; j < 4; j++)
							B[k * 8 + bias + j][q * 8 + bias + i] = A[k * 8 + i][q * 8 + j];
					for (i = 0; i < 4; i++)
						for (j = 4; j < 8; j++)
							B[k * 8 + bias + j][q * 8 + bias + i] = A[k * 8 + i][q * 8 + j];
					for (i = 4; i < 8; i++)
						for (j = 4; j < 8; j++)
							B[q * 8 + bias + j][q * 8 + bias + i] = A[k * 8 + i][q * 8 + j];
					for (i = 4; i < 8; i++)
						for (j = 0; j < 4; j++)
							B[k * 8 + bias + j][q * 8 + bias + i] = A[k * 8 + i][q * 8 + j];
					
				}
				else
				{
					// 对于不在对角线上的12个8*8的普通格，每个格还是一分为四，每小格为4*4，按照1，2，4，3的顺序从A转置存到B

					for (i = 0; i < 4; i++)
						for (j = 0; j < 4; j++)
							B[q * 8 + j][k * 8 + i] = A[k * 8 + i][q * 8 + j];
					for (i = 0; i < 4; i++)
						for (j = 4; j < 8; j++)
							B[q * 8 + j][k * 8 + i] = A[k * 8 + i][q * 8 + j];
					for (i = 4; i < 8; i++)
						for (j = 4; j < 8; j++)
							B[q * 8 + j][k * 8 + i] = A[k * 8 + i][q * 8 + j];
					for (i = 4; i < 8; i++)
						for (j = 0; j < 4; j++)
							B[q * 8 + j][k * 8 + i] = A[k * 8 + i][q * 8 + j];
				}

				// 交换
				if (k == q && k % 2 == 1)
				{
					
					for (i = 0; i < 4; i++)
						for (j = 0; j < 4; j++)
							swap(&B[k * 8 + i][q * 8 + j], &B[k * 8 - 8 + i][q * 8 - 8 + j]);
					for (i = 0; i < 4; i++)
						for (j = 4; j < 8; j++)
							swap(&B[k * 8 + i][q * 8 + j], &B[k * 8 - 8 + i][q * 8 - 8 + j]);
					for (i = 4; i < 8; i++)
						for (j = 0; j < 4; j++)
							swap(&B[k * 8 + i][q * 8 + j], &B[k * 8 - 8 + i][q * 8 - 8 + j]);
					
					for (i = 4; i < 8; i++)
						for (j = 4; j < 8; j++)
							swap(&B[k * 8 + i][q * 8 + j], &B[k * 8 - 8 + i][q * 8 - 8 + j]);
					
				}

			}
		}
		
	}

61 × 67

要求m<2000，比较宽松。

成功：bsize=16*16

    if (M == 61 && N == 67)
	{
	
		int bsize_x = 16;
		int bsize_y = 16;
		for (k = 0; k <= 67/bsize_x; k++)
			for (q = 0; q <= 61/bsize_y; q++)
				for (i = 0; i < bsize_x && k*bsize_x+i<67; i++)
					for (j = 0; j < bsize_y && q*bsize_y+j < 61; j++)
						B[q * bsize_y  + j][k * bsize_x  + i] = A[k * bsize_x  + i][q * bsize_y  + j];

		
	}

测试

注意测试程序driver.py要用python2运行，python3是报错的 

BU冰糖雪梨里的梨PT
关注
  • 22
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LLMs之ToolAgent：基于LangChain框架(+LangSmith跟踪)来创建一个能够利用工具（如搜索引擎和文档检索器）以及参考聊天历史信息来响应用户输入的代理——定义工具转换为AGent
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-17 1359
​ LLMs之Agent之Tool Calling Agent：基于LangChain框架(+LangSmith跟踪)来创建一个能够利用工具（如搜索引擎和文档检索器）以及参考聊天历史信息来响应用户输入的代理——定义工具转换为AGent格式并创建工具列表(Tavily【在线搜索】和和Retriever【本地检索】)→创建Agent(定义llm【ChatOpenAI+温度为0】和prompt+定义Agent【使用LLM、Prompt和Tools来初始化Agent】+定义Agent执行器【思考这些组件】)→创建并
windows 下 基于 WSL2安装DeepSpares进行YOLOV8 v5 的加速推理
最新发布
shiter编写程序的艺术
06-12 172
硬件要求：CPU 支持 avx2 指令集软件：操作系统只支持Linux可以通过查看CPU的规格或者使用特定的命令来检测CPU是否支持AVX2指令集。查看CPU规格：直接查看CPU的规格说明，通常在购买CPU时，其包装或者产品描述中会明确指出支持的指令集。访问CPU制造商的官方网站，通过搜索型号可以获取详细的CPU规格信息。使用系统命令：在Linux系统中，可以使用命令cat /proc/cpuinfo来查看CPU信息。
PC下通用矩阵乘优化（近30倍性能提升）
XiaoHeiBlack的专栏
06-08 1368
通用矩阵乘的十种实现（intel平台） 前言 在intel平台上对矩阵乘进行优化，主要依靠内存排布（for cache friendly）、SIMD（SSE）、多线程等方法。A，B，C矩阵大小分别为MK,KN,MN。性能数据为M=N=K=1024下循环T次下的平均性能。下面给出公式和示意图，可以对照着理解代码。 Cm,n=∑n=1KAm,k∗Bk,nC_{m,n}=\sum_{n=1}^KA_{m,k}*B_{k,n}Cm,n​=n=1∑K​Am,k​∗Bk,n​ v0.严格按照定义的实现 完全按照数学定
程序性能优化探讨（6）——矩阵乘法优化之分块矩阵
热门推荐
u013471946的专栏
02-26 1万+
有一种性格叫做偏执，有一种矩阵优化运算叫做分块。实话说，也许我这辈子也用不上这种随牛B但很复杂的算法，有些版本的教材直接删除这个内容。但越是这样我越想不过，因此借写这篇博客，把分块矩阵乘法彻底分析清楚。          把矩阵乘法进行分块优化，很奇妙的算法，假设我们要做11X11矩阵乘法，AXB = C原本是这样算的：         比如我们要计算C1.2，就要把上图的
矩阵乘法的优化
ludan_xia的博客
05-06 1968
1、第一点利用Cache的特点，把大矩阵乘法变成小矩阵的乘法（分治法的思想） https://blog.csdn.net/weixin_40673608/article/details/88135041?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-1&depth_1-utm_source...
分块矩阵操作：高性能计算策略
光剑书架上的书
01-07 1267
1.背景介绍 分块矩阵是一种常见的矩阵表示，在许多领域中都有广泛应用，例如线性代数、数值分析、计算机图形学、机器学习等。在这些领域中，分块矩阵操作是一个重要的问题，其计算效率和算法性能对于应用的性能具有重要影响。因此，研究分块矩阵操作的高性能计算策略具有重要的理论和实际意义。 在本文中，我们将从以下几个方面进行深入探讨： 背景介绍 核心概念与联系 核心算法原理和具体操作步骤以及数学模型公式...
论文阅读:矩阵乘法GEMM的cache优化,子矩阵的切分方法Anatomy of High-Performance MatrixMultiplication
weixin_55035144的博客
07-21 798
矩阵乘法的优化需要将矩阵切分成子矩阵，用子矩阵相乘的结果组合为原矩阵相乘的结果：上图是拆分矩阵的方法，M表示矩阵，X方向和Y方向的两个维度都是未知的。P表示横条或竖条，X方向或Y方向有一个方向的维度是极小的。B表示block块，X方向和Y方向的两个维度都是极小的。为了减小单个子矩阵计算量，要拆开A的整行和B的整列。不能让和作为子矩阵。因此下图中第二列的Fig8和Fig10拆得最好，把A按列拆，使A的行不再完整，把B按行拆，使B的列不再完整。
sketch52.6
01-17
mac版本sketch52.6，Sketch 是一款适用于所有设计师的矢量绘图应用。矢量绘图也是目前进行网页，图标以及界面设计的最好方式。但除了矢量编辑的功能之外，我们同样添加了一些基本的位图工具，比如模糊和色彩校正。
Firefox火狐浏览器官方52.6.0esr-mac版本dmg安装包
12-28
Firefox火狐浏览器是一款深受用户喜爱的开源网络浏览器，其官方52.6.0esr-mac版本专为Mac操作系统设计。此版本是Extended Support Release（ESR）的分支，意味着它提供更长期的更新和支持，主要针对企业环境和那些...
leetcode2sumc-Leetcode-in-CPlusPlus-:C++/LeetCode多合一
07-06
leetcode 2 和 c Leetcode-in-C plus plus- # 树 解决方案 困难 144 66.6% 中等的 94 58.1% 中等的 145 58.4% 中等的 102 57.2% 中等的 107 55.7% 中等的 # 树（预购） 解决方案 困难 ...52.6% 简单的
CSAPP_cachelab Part A解答
05-04
经典的缓存实验 cache lab,CMU大学(卡耐基 梅隆大学)经典计算机课程实验之一, 实验分为两部分, 这里面只有Part A的答案.
csapp cache lab 满分原创（北大&cmu;） 仅供参考，请勿抄袭
12-27
csapp cache lab 满分原创（北大&cmu;） 仅供参考，请勿抄袭
代码性能优化——分块技巧
qq_33269219的博客
12-30 1611
代码性能优化——分块技巧 同样的算法、同样的计算量，一些高手写的程序可能比初学者的快百倍。像MKL、Openblas这些专业的计算库，更是将性能优化到了极致。 那么他们是怎么做到的呢？本篇我们就从分块技巧开始来管中窥豹一下。 代码实例 开门见山，以一个实用的程序作为例子：向量乘矩阵 如图所示,M个元素的向量乘以M行N列的矩阵，生成N个元素的向量。 基本代码如下： #define M (2048) #define N (1024) static void naive(float vec_in[M], fl
通用矩阵乘（GEMM）优化算法从入门到实践
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
10-13 1375
矩阵乘的算法优化可分为两类：基于算法分析的方法：根据矩阵乘计算特性，从数学角度优化，典型的算法包括 Strassen 算法和 Coppersmith–Winograd 算法。基于软件优化的方法：根据计算机存储系统的层次结构特性，选择性地调整计算顺序，主要有循环拆分向量化、内存重排等。
矩阵乘法的分块优化
sinat_22510827的博客
04-22 1355
普通矩阵乘法一般采用3重循环完成。 void dgemm (int n, double* A, double* B, double* C) {undefined for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {undefined double cij = C[i+j*n]; /* cij = C[i][j] */ for(int k = 0; k < n; k++ )...
分块矩阵操作：GPU加速实践
光剑书架上的书
12-31 1130
1.背景介绍 分块矩阵是一种常见的矩阵表示，在许多领域中得到广泛应用，如线性代数、数值分析、计算机图形学、机器学习等。随着数据规模的不断增加，传统的矩阵计算方法已经无法满足实际需求，因此需要寻找更高效的矩阵计算方法。GPU(图形处理器)作为一种高性能并行计算设备，具有显著的计算优势，可以用于加速矩阵计算。 本文将从以下几个方面进行阐述： 背景介绍 核心概念与联系 核心算法原理和具体操作步骤...
矩阵乘法(GEMM)优化算法在GPU上的实现
m0_72410588的博客
05-26 1257
矩阵乘法的基本思路是将两个矩阵相应位置的元素相乘，并累加得到结果矩阵的对应位置的元素。设AAA为形状为m×km\times km×k的矩阵，BBB为形状为k×nk \times nk×n的矩阵，则得到的矩阵CCC形状为m×nm \times nm×n，其中第iii行第jjj列的元素为Cij∑r1kAirBrjCij​r1∑k​Air​Brj​。
两种不同分块算法及基本矩阵乘法的毫秒级效率比较（横切、纵切、竖切进行矩阵分块以及运用多线程来优化的矩阵乘法。
m0_63689135的博客
12-26 305
【代码】两种不同分块算法及基本矩阵乘法的毫秒级效率比较（横切、纵切、竖切进行矩阵分块以及运用多线程来优化的矩阵乘法。
基于GPU的GEMM矩阵相乘运算优化
weixin_55035144的博客
06-12 984
从上图中我们可以看到三种处理方法。第一种是将A和B矩阵分块，第二种方法是将C和B矩阵分块，第三种方法是将C和A矩阵分块。GEMM的子任务是GEPP或GEMP；最小粒度的任务是GEBP或GEPB或点乘。
是德科技：5G一致性测试关键策略与标准进展
5G技术不仅涉及高频段的使用，如频率范围2（FR2）的24.25至52.6GHz，这显著增加了测试的复杂性，还要求设备和基站能支持更大的传输带宽和新型接入技术。 4G与5G的协同对接至关重要，以确保无缝用户体验。在设备厂商...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值