perflab 课程设计

已于 2022-12-13 10:33:19 修改
阅读量479 收藏
点赞数
文章标签： 算法 c++ 开发语言
于 2022-12-06 17:48:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ykrsgs/article/details/128201833
版权

初始状态

rotate

版本I

因为本题步步都在寻址而寻址的目标每一步又不同，并且在一个地址的值一次就赋值完毕，不会对同一个地址进行二次寻址，所以我首先想的改进方向就是使得寻址更加快速，于是我使得寻址的地址更加连续。

int i, j, t,n;
    n = dim - 1;
    for (j = 0; j < dim; j++){
        t = (n-j)*dim;
        for (i = 0; i < dim; i++)
            dst[t+i] = src[RIDX(i, j, dim)];
    }

 

 版本II

为了降低CPE，可以降低cache miss，所以可以用块化即通过不断使用一些数据块，而不是完整地遍历一行和一列，来改进空间局部性。

int i,j,ki,kj;
   for (i = 0; i < dim; i+=8) 
    for (j = 0; j < dim; j+=8)
        for(ki=i; ki<i+8; ki++) 
            for(kj=j; kj<j+8; kj++) 
                    dst[RIDX(dim-1-kj, ki, dim)] = src[RIDX(ki, kj, dim)];

Rotate的Summary由5.0提高至7.9，Dim规模较小时CPE优化不明显，当Dim规模较大时CPE明显下降

版本III

将前两种方法结合

int i, j, a, b, t;
    int sdim = dim - 1;
    for (i = 0; i < dim; i += 8)
    {
        for (j = 0; j < dim; j += 8)
        {
            for (b = j; b < j + 8; b++)
            {
                t = (sdim - b)*dim; 
                for (a = i; a < i + 8; a++)
                {
                    dst[t+a] = src[RIDX(a, b, dim)];
                }
            }
        }
    }

 版本IV

考虑到程序过多次调用RIDX函数，故消除该函数的调用。此外，改善读写顺序。具体来说，先处理矩阵第一列的前32个元素，再处理第二列前32个元素，以此类推直到处理完毕矩阵的前32行，再以相同的方法继续处理余下的矩阵元素。

int i,j,k;
for (i = 0; i < dim; i+=32)
    for (j = 0; j < dim; j++)
        for(k=0; k<32; k++) {
           dst[(dim-1-j)*dim+i+k] = src[(i+k)*dim+j];
        }

smooth

版本I

虽然不同位置的像素点需要取相邻的不同数目的像素点的平均值，但数目只有4、6、9。对于四个顶点，取相邻四个像素点的平均值；对于和顶点接壤的像素点，取相邻六个像素点的平均值；剩下的取相邻九个像素点的平均值。

	int i=1,j=0;
	//左上角
	dst[0].red=(src[0].red+src[1].red+src[dim].red+src[dim+1].red)/4;
	dst[0].green=(src[0].green+src[1].green+src[dim].green+src[dim+1].green)/4;
	dst[0].blue=(src[0].blue+src[1].blue+src[dim].blue+src[dim+1].blue)/4;
	//第一行其他非右上角顶点
	for(j=1; j<dim-1; j++) {
		dst[j].red=(src[j-1].red+src[j].red+src[j+1].red+src[dim+j-1].red+src[dim+j].red+src[dim+j+1].red)/6;
		dst[j].green=(src[j-1].green+src[j].green+src[j+1].green+src[dim+j-1].green+src[dim+j].green+src[dim+j+1].green)/6;
		dst[j].blue=(src[j-1].blue+src[j].blue+src[j+1].blue+src[dim+j-1].blue+src[dim+j].blue+src[dim+j+1].blue)/6;
	}
	//右上角顶点
	dst[j].red=(src[j].red+src[j-1].red+src[dim+j].red+src[dim+j-1].red)/4;
	dst[j].green=(src[j].green+src[j-1].green+src[dim+j].green+src[dim+j-1].green)/4;
	dst[j].blue=(src[j].blue+src[j-1].blue+src[dim+j].blue+src[dim+j-1].blue)/4;
	//1至dim-2行
	for(; i<dim-1; i++) {
		//每行第一个像素点
		dst[i*dim].red=(src[(i-1)*dim].red+src[(i-1)*dim+1].red+src[i*dim].red+src[i*dim+1].red+src[(i+1)*dim].red+src[(i+1)*dim+1].red)/6;
		dst[i*dim].green=(src[(i-1)*dim].green+src[(i-1)*dim+1].green+src[i*dim].green+src[i*dim+1].green+src[(i+1)*dim].green+src[(i+1)*dim+1].green)/6;
		dst[i*dim].blue=(src[(i-1)*dim].blue+src[(i-1)*dim+1].blue+src[i*dim].blue+src[i*dim+1].blue+src[(i+1)*dim].blue+src[(i+1)*dim+1].blue)/6;
		//每行第二个至第dim-1个像素点
		for(j=1; j<dim-1; j++) {
			dst[i*dim+j].red=(src[(i-1)*dim+j-1].red+src[(i-1)*dim+j].red+src[(i-1)*dim+j+1].red+src[i*dim+j-1].red+src[i*dim+j].red+src[i*dim+j+1].red+src[(i+1)*dim+j-1].red+src[(i+1)*dim+j].red+src[(i+1)*dim+j+1].red)/9;
			dst[i*dim+j].green=(src[(i-1)*dim+j-1].green+src[(i-1)*dim+j].green+src[(i-1)*dim+j+1].green+src[i*dim+j-1].green+src[i*dim+j].green+src[i*dim+j+1].green+src[(i+1)*dim+j-1].green+src[(i+1)*dim+j].green+src[(i+1)*dim+j+1].green)/9;
			dst[i*dim+j].blue=(src[(i-1)*dim+j-1].blue+src[(i-1)*dim+j].blue+src[(i-1)*dim+j+1].blue+src[i*dim+j-1].blue+src[i*dim+j].blue+src[i*dim+j+1].blue+src[(i+1)*dim+j-1].blue+src[(i+1)*dim+j].blue+src[(i+1)*dim+j+1].blue)/9;
		}
		//每行最后一个像素点
		dst[i*dim+j].red=(src[(i-1)*dim+j-1].red+src[(i-1)*dim+j].red+src[i*dim+j-1].red+src[i*dim+j].red+src[(i+1)*dim+j-1].red+src[(i+1)*dim+j].red)/6;
		dst[i*dim+j].green=(src[(i-1)*dim+j-1].green+src[(i-1)*dim+j].green+src[i*dim+j-1].green+src[i*dim+j].green+src[(i+1)*dim+j-1].green+src[(i+1)*dim+j].green)/6;
		dst[i*dim+j].blue=(src[(i-1)*dim+j-1].blue+src[(i-1)*dim+j].blue+src[i*dim+j-1].blue+src[i*dim+j].blue+src[(i+1)*dim+j-1].blue+src[(i+1)*dim+j].blue)/6;
	}
	//左下角
	dst[i*dim].red=(src[(i-1)*dim].red+src[(i-1)*dim+1].red+src[i*dim].red+src[i*dim+1].red)/4;
	dst[i*dim].green=(src[(i-1)*dim].green+src[(i-1)*dim+1].green+src[i*dim].green+src[i*dim+1].green)/4;
	dst[i*dim].blue=(src[(i-1)*dim].blue+src[(i-1)*dim+1].blue+src[i*dim].blue+src[i*dim+1].blue)/4;
	//最后一行非左下角、非右下角的像素点
	for(j=1; j<dim-1; j++) {
		dst[i*dim+j].red=(src[(i-1)*dim+j-1].red+src[(i-1)*dim+j].red+src[(i-1)*dim+j+1].red+src[i*dim+j-1].red+src[i*dim+j].red+src[i*dim+j+1].red)/6;
		dst[i*dim+j].green=(src[(i-1)*dim+j-1].green+src[(i-1)*dim+j].green+src[(i-1)*dim+j+1].green+src[i*dim+j-1].green+src[i*dim+j].green+src[i*dim+j+1].green)/6;
		dst[i*dim+j].blue=(src[(i-1)*dim+j-1].blue+src[(i-1)*dim+j].blue+src[(i-1)*dim+j+1].blue+src[i*dim+j-1].blue+src[i*dim+j].blue+src[i*dim+j+1].blue)/6;
	}
	//右下角像素点
	dst[i*dim+j].red=(src[(i-1)*dim+j-1].red+src[(i-1)*dim+j].red+src[i*dim+j-1].red+src[i*dim+j].red)/4;
	dst[i*dim+j].green=(src[(i-1)*dim+j-1].green+src[(i-1)*dim+j].green+src[i*dim+j-1].green+src[i*dim+j].green)/4;
	dst[i*dim+j].blue=(src[(i-1)*dim+j-1].blue+src[(i-1)*dim+j].blue+src[i*dim+j-1].blue+src[i*dim+j].blue)/4;

版本II

由于上个版本程序运行过程中比较多的重复计算区域，基于动态规划的思想，将每一个像素点的计算转换为一个块(2x2或2x3或3x2或3x3)内的各个像素点取平均值，并将每一块纵向分开为2或3个纵向块，用动规数组记录每一列(2个或3个像素点)的RGB之和，其中相邻的两个纵向块之间的递推关系通式为：dp[i][j]=dp[i-1][j]-src[(i-1)*dim+j]+src[(i+2)*dim+j]

	int i,j;
	int r2[2][dim],g2[2][dim],b2[2][dim];
	int r3[dim][dim],g3[dim][dim],b3[dim][dim];
	for(j=0; j<dim; j++) {
		//第j列一开始的大小为2的子块
		r2[0][j]=src[j].red;
		g2[0][j]=src[j].green;
		b2[0][j]=src[j].blue;
		r2[0][j]+=src[dim+j].red;
		g2[0][j]+=src[dim+j].green;
		b2[0][j]+=src[dim+j].blue;
		//第j列一开始的大小为3的子块
		r3[0][j]=r2[0][j]+src[(dim<<1)+j].red;
		g3[0][j]=g2[0][j]+src[(dim<<1)+j].green;
		b3[0][j]=b2[0][j]+src[(dim<<1)+j].blue;
		//其他子块
		for(i=1; i<dim-2; i++) {
			r3[i][j]=r3[i-1][j]-src[(i-1)*dim+j].red+src[(i+2)*dim+j].red;
			g3[i][j]=g3[i-1][j]-src[(i-1)*dim+j].green+src[(i+2)*dim+j].green;
			b3[i][j]=b3[i-1][j]-src[(i-1)*dim+j].blue+src[(i+2)*dim+j].blue;
		}
		//最后一个长度为2的子块
		r2[1][j]=r3[dim-3][j]-src[(dim-3)*dim+j].red;
		g2[1][j]=g3[dim-3][j]-src[(dim-3)*dim+j].green;
		b2[1][j]=b3[dim-3][j]-src[(dim-3)*dim+j].blue;
	}
	//处理左上角顶点
	dst[0].red=(r2[0][0]+r2[0][1])/4;
	dst[0].green=(g2[0][0]+g2[0][1])/4;
	dst[0].blue=(b2[0][0]+b2[0][1])/4;
	//处理第一行其他非右上角顶点
	for(j=1; j<dim-1; j++) {
		dst[j].red=(r2[0][j-1]+r2[0][j]+r2[0][j+1])/6;
		dst[j].green=(g2[0][j-1]+g2[0][j]+g2[0][j+1])/6;
		dst[j].blue=(b2[0][j-1]+b2[0][j]+b2[0][j+1])/6;
	}
	//右上角顶点
	dst[j].red=(r2[0][j-1]+r2[0][j])/4;
	dst[j].green=(g2[0][j-1]+g2[0][j])/4;
	dst[j].blue=(b2[0][j-1]+b2[0][j])/4;
	//1至dim-2行
	for(i=1; i<dim-1; i++) {
		//每行的第一个像素点
		dst[i*dim].red=(r3[i-1][0]+r3[i-1][1])/6;
		dst[i*dim].green=(g3[i-1][0]+g3[i-1][1])/6;
		dst[i*dim].blue=(b3[i-1][0]+b3[i-1][1])/6;
		//每行第二个至第dim-1个像素点
		for(j=1; j<dim-1; j++) {
			dst[i*dim+j].red=(r3[i-1][j-1]+r3[i-1][j]+r3[i-1][j+1])/9;
			dst[i*dim+j].green=(g3[i-1][j-1]+g3[i-1][j]+g3[i-1][j+1])/9;
			dst[i*dim+j].blue=(b3[i-1][j-1]+b3[i-1][j]+b3[i-1][j+1])/9;
		}
		//每行最后一个像素点
		dst[i*dim+j].red=(r3[i-1][j-1]+r3[i-1][j])/6;
		dst[i*dim+j].green=(g3[i-1][j-1]+g3[i-1][j])/6;
		dst[i*dim+j].blue=(b3[i-1][j-1]+b3[i-1][j])/6;
	}
	//左下角像素点
	dst[i*dim].red=(r2[1][0]+r2[1][1])/4;
	dst[i*dim].green=(g2[1][0]+g2[1][1])/4;
	dst[i*dim].blue=(b2[1][0]+b2[1][1])/4;
	//最后一行非左下角、非右下角的像素点
	for(j=1; j<dim-1; j++) {
		dst[i*dim+j].red=(r2[1][j-1]+r2[1][j]+r2[1][j+1])/6;
		dst[i*dim+j].green=(g2[1][j-1]+g2[1][j]+g2[1][j+1])/6;
		dst[i*dim+j].blue=(b2[1][j-1]+b2[1][j]+b2[1][j+1])/6;	
	}
	//右下角像素点
	dst[i*dim+j].red=(r2[1][j-1]+r2[1][j])/4;
	dst[i*dim+j].green=(g2[1][j-1]+g2[1][j])/4;
	dst[i*dim+j].blue=(b2[1][j-1]+b2[1][j])/4;

版本III

版本I将处理方式不同的位置分别讨论，但大量的重复计算限制了性能，而版本II的纵向三个像素点的R、G、B之和与二维数组的选择不够合理。又因为对任何像素点，待求平均的像素点所构成的块大小都不会超过三行，每行都不会超过三个。所以可以通过三个指针，每个指针控制行相邻的两个或三个像素点的读运算。

void smooth3(int dim, pixel *src, pixel *dst) {
	//使用指针，尽量少移动
    int i,j;
	//每一个指针对应一行
    pixel *pixelA,*pixelB,*pixelC;
    int size = dim-1;
    //处理第一行第一个像素点
    pixelB = src;
    pixelC = pixelB + dim;
    dst->red = (pixelB->red + (pixelB+1)->red + pixelC->red + (pixelC+1)->red)>>2;
    dst->green = (pixelB->green + (pixelB+1)->green + pixelC->green + (pixelC+1)->green)>>2;
    dst->blue = (pixelB->blue + (pixelB+1)->blue + pixelC->blue + (pixelC+1)->blue)>>2;
    pixelB++;
    pixelC++;
    dst++;
    //处理第一行中间的dim-2个像素点
    for(i = 1; i < size; i++)
    {
        dst->red = (pixelB->red + (pixelB-1)->red + (pixelB+1)->red + pixelC->red + (pixelC-1)->red + (pixelC+1)->red)/6;
        dst->green = (pixelB->green + (pixelB-1)->green + (pixelB+1)->green + pixelC->green + (pixelC-1)->green + (pixelC+1)->green)/6;
        dst->blue = (pixelB->blue + (pixelB-1)->blue + (pixelB+1)->blue + pixelC->blue + (pixelC-1)->blue + (pixelC+1)->blue)/6;
        pixelB++;
        pixelC++;
        dst++;
    }
    //处理第一行最后一个像素点
    dst->red = (pixelC->red + (pixelC-1)->red + pixelB->red + (pixelB-1)->red)>>2;
    dst->green = (pixelC->green + (pixelC-1)->green + pixelB->green + (pixelB-1)->green)>>2;
    dst->blue = (pixelC->blue + (pixelC-1)->blue + pixelB->blue + (pixelB-1)->blue)>>2;
    dst++;
	//开始处理中间的dim-2行
    pixelA = src;
    pixelB = pixelA + dim;
    pixelC = pixelB + dim;
    for(i = 1; i < size; i++)
    {
        //对于每一行的第一个像素点
        dst->red = (pixelA->red + (pixelA+1)->red + pixelB->red + (pixelB+1)->red + pixelC->red + (pixelC+1)->red)/6;
        dst->green = (pixelA->green + (pixelA+1)->green + pixelB->green + (pixelB+1)->green + pixelC->green + (pixelC+1)->green)/6;
        dst->blue = (pixelA->blue + (pixelA+1)->blue + pixelB->blue + (pixelB+1)->blue + pixelC->blue+ (pixelC+1)->blue)/6;
        dst++;
        pixelA++;
        pixelB++;
        pixelC++;
        //对于每一行中间的dim-2个像素点
        for(j = 1; j < dim-1; j++)
        {
            dst->red = (pixelA->red + (pixelA-1)->red + (pixelA+1)->red + pixelB->red + (pixelB-1)->red + (pixelB+1)->red + pixelC->red + (pixelC-1)->red + (pixelC+1)->red)/9;
            dst->green = (pixelA->green + (pixelA-1)->green + (pixelA+1)->green + pixelB->green + (pixelB-1)->green + (pixelB+1)->green + pixelC->green + (pixelC-1)->green + (pixelC+1)->green)/9;
            dst->blue = (pixelA->blue + (pixelA-1)->blue + (pixelA+1)->blue + pixelB->blue + (pixelB-1)->blue + (pixelB+1)->blue + pixelC->blue + (pixelC-1)->blue + (pixelC+1)->blue)/9;
            pixelA++;
            pixelB++;
            pixelC++;
            dst++;
        }
        //对于每一行最后一个像素点
        dst->red = (pixelA->red + (pixelA-1)->red + pixelB->red + (pixelB-1)->red + pixelC->red + (pixelC-1)->red)/6;
        dst->green = (pixelA->green + (pixelA-1)->green + pixelB->green + (pixelB-1)->green + pixelC->green + (pixelC-1)->green)/6;
        dst->blue = (pixelA->blue + (pixelA-1)->blue + pixelB->blue + (pixelB-1)->blue + pixelC->blue+ (pixelC-1)->blue)/6;
        pixelA++;
        pixelB++;
        pixelC++;
        dst++;
    }
    //处理最后一行第一个像素点
    dst->red = (pixelA->red + (pixelA+1)->red + pixelB->red + (pixelB+1)->red)>>2;
    dst->green = (pixelA->green + (pixelA+1)->green + pixelB->green + (pixelB+1)->green)>>2;
    dst->blue = (pixelA->blue + (pixelA+1)->blue + pixelB->blue + (pixelB+1)->blue)>>2;
    dst++;
    pixelA++;
    pixelB++;
    //处理最后一行中间dim-2个像素点
    for(i = 1; i < size; i++)
    {
        dst->red = (pixelA->red + (pixelA-1)->red + (pixelA+1)->red + pixelB->red + (pixelB-1)->red + (pixelB+1)->red)/6;
        dst->green = (pixelA->green + (pixelA-1)->green + (pixelA+1)->green + pixelB->green + (pixelB-1)->green + (pixelB+1)->green)/6;
        dst->blue = (pixelA->blue + (pixelA-1)->blue + (pixelA+1)->blue + pixelB->blue + (pixelB-1)->blue + (pixelB+1)->blue)/6;
        pixelA++;
        pixelB++;
        dst++;
    }
    //处理最后一行最后一个像素点
    dst->red = (pixelA->red + (pixelA-1)->red + pixelB->red + (pixelB-1)->red)>>2;
    dst->green = (pixelA->green + (pixelA-1)->green + pixelB->green + (pixelB-1)->green)>>2;
    dst->blue = (pixelA->blue + (pixelA-1)->blue + pixelB->blue + (pixelB-1)->blue)>>2;
}

 

Erick Yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
perflab实验报告.doc
03-27
perflab实验报告
csapp perflab
06-22
计算机体系结构的performance lab，分数为17.8和22.2，可直接使用
perflab实验报告
06-12
perflab——代码性能优化，兼顾算法原型的理解，学会以底层的角度对抽象计算作最大限度的优化。
湖南大学计算机组成与结构perflab实验源码及报告
10-01
湖南大学计算机组成与结构perflab实验源码及报告
中科大csapp实验4 perflab-handout 代码优化
01-07
中科大程序设计与计算机系统，实验4，代码优化，亲测可用，版本优化相当高
ics lab8 perflab性能优化实验
10-31
自己写的csapp上的性能优化实验的kernels.c。
深入理解计算机系统——实验 Perflab
悲伤无声地涌出来
04-06 8278
一、前言 1、对程序进行优化时要使优化后得到的程序和未优化的版本有一样的行为。 2、不依赖与目标机器的的特性的常见代码优化方法有：消除循环的低效率、减少过程调用、消除不必要的存储器引用 3、这次实验主要对两个函数进行优化，rotate函数和smooth函数 rotate函数要求将二维矩阵逆时针旋转90度 smooth函数要求将二维矩阵中每个元素的值替换为周围相邻元素的算术平均值 4、To...
CSAPP实验四：性能优化实验（Perflab）
热门推荐
CNFINITE的博客
08-12 1万+
本系列文章为中国科学技术大学计算机专业学科基础课《计算机系统》布置的实验，上课所用教材和内容为黑书CSAPP，当时花费很大精力和弯路，现来总结下各个实验，本文章为第四个实验——性能优化实验（Perflab）。 一、实验名称：perflab 二、实验学时： 3 三、实验内容和目的： 此次实验进行图像处理代码的优化。图像处理提供了许多能够通过优化而得到改良的函数。在此次实验中，我们将考虑两种图像处理操作：roate， 此函数用于将图像逆时针旋转90°；以及smooth，对图像...
[CSAPP] Performance Lab 实验笔记
康宇的博客
07-06 3296
perflab这节的任务是利用书中知识，来对图像处理中的Rotate和Smooth操作函数进行优化。这次没对上电波，觉得学了一堆屠龙之技。于我个人理解，现在计算机配置比以前高多了，连SWAP分区都几近废弃了，对于一般开发者来讲，代码效率瓶颈首先是架构，其次是算法，最后才是书里教的这些小细节。而且这节也没个具体的分数标准，优化了半天也不知道自己写的算啥水平，缺了前面几节那种攻克难题的成就感。不过也有可能是因为我太菜了 XD 前期准备 这次的开发环境被我迁移到了WSL上，系统版本为ubuntu 18.04 LT
PerfLab（直接在服务器上完成）
weixin_43320890的博客
12-08 1026
PerfLab 性能优化实验（直接在服务器上完成） 1.实验前的准备 1.1 登录服务器：打开cmd，输入指令ssh 49.123.112.130 -用户名 1.2 初始化：输入指令perf_init（初始化只需要在第一次登陆时操作，以后如果再次初始化会将自己所做的所有修改清空） 1.3 打开目录，输入指令：cd perfLab 2. 修改Makefile文件 2.1 输入指令vim Makefile ...
【笔记】南大操作系统jyy
qq_43050258的博客
03-16 1961
南京大学蒋炎岩操作系统设计与实现课程笔记
早鸟报名：《360° 剖析 Linux ELF》在线课程
Linux阅码场
10-02 828
本课程通过一个最小的点，带动一个知识面的片。围绕Hello ELF裁剪，从Linux等主流操作系统的可执⾏⽂件格式、 ELF规范、体系结构和指令集到代码编译、静态链接、共...
CSAPP-MallocLab
qq_45531291的博客
01-21 2679
CSAPP课本配套实验：MallocLab，实现自己的malloc、free、realloc函数
【LittleXi】cache_lab超简单详解
qq_68591679的博客
11-19 4224
【LittleXi】cache_lab超简单详解
计算机系统perflab实验——PartA部分
qq_45846025的博客
04-04 428
计算机系统perflab实验——PartA部分 第一步需要解决如何把Windows内文件复制进虚拟机， 先将下载的安装包解压，因为我的virtualbox设置的是自动缩放模式，所以找不到设备，需要先将视图调成全屏或者无缝模式（right ctr+F或者right ctr+L），找到任务栏的设备：将共享粘贴板和拖放都设置为双向，再安装增强功能。 安装好了就把解压的文件拖进主文件夹目录下。 在更改函数之前，需要注意以下几点： 1.需要把团队信息更改，不然会报错 2.不要在原代码上改，你可以重新自己构建函数，
perflab实验日志一
imotolove的博客
11-18 5696
一、实验内容 1、通过改写rotate和smooth函数，对程序进行优化，最后通过查看加速比和cep 得出最终的结果，cep越小越好，加速比越大越好 二、相关知识 程序优化的方法 ： 循环展开 代码移位 消除不必要的过程调用 代码剖析程序：测量程序各个部分性能的工具，分析代码中低效的地方。 大多数的编译器都提供优化控制：gcc而言 -o1,-o2,-o3 让编译更全面优化 存储...
perflab优化1
qq_43723613的博客
03-29 1169
perflab实验第一周 一． 实验前的准备 搭建实验环境，在虚拟机中安装linux操作系统，安装gcc编译器，gdb调试环境，下载相关资料，阅读英文说明文档perflab.pdf，了解实验内容 二． 实验要求 修改kernel.c的源代码，对roate函数进行优化 查看Makefile文件中不同的make指令并用make编译生成可执行文件driver，用 . /driver测试修改后程序的加速比...
深入理解计算机系统CSAPP-perfLab：kernels.c性能优化实验：rotate优化详细实验日志（含六个优化版本）
乔卿的博客
11-05 1万+
目录一、实验内容二、相关知识三、实验步骤四、 程序优化各个版本初始版本版本一：分块，旨在提高空间局部性版本二：在分块的基础上，循环展开(降低了循环开销，但牺牲程序的尺寸)版本三：在前两个版本的基础上，改善读写顺序版本四：修改pixel结构，旨在令每一个像素点占1整个块版本五：消除函数调用并改善读写顺序。版本六：改善读写顺序并循环站靠。五、遇到的问题及解决方法 一、实验内容 1、 学习图像旋转与图像...
力扣LCP 08.剧情触发时间
最新发布
Pisasama的博客
06-12 409
【代码】力扣LCP 08.剧情触发时间。
perf flamegraph
01-25
perf flamegraph是一种性能分析工具，用于可视化和分析程序的性能瓶颈和热点代码。 perf flamegraph基于Linux操作系统的perf工具，通过收集程序执行期间的硬件性能计数器数据，并将其转化为可视化图形表示。这些...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值