CSAPP Lab4- PerfLab

最新推荐文章于 2023-08-16 17:14:49 发布
最新推荐文章于 2023-08-16 17:14:49 发布
阅读量1.4k 收藏 16
点赞数 3
分类专栏： CSAPP 文章标签： CSAPP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43844521/article/details/130793218
版权

代码优化 

typedef struct { 
    unsigned short red; /* R value */ 
    unsigned short green; /* G value */ 
    unsigned short blue; /* B value */ 
} pixel

图像用一维数组表示，第（i,j）个像素表示为I[RIDX(i,j,n)]，n为图像的维数

#define RIDX(i,j,n) ((i)*(n)+(j))

旋转操作

void naive_rotate(int dim, pixel *src, pixel *dst) { 
    int i, j; 
    for(i=0; i < dim; i++) 
    for(j=0; j < dim; j++) 
        dst[RIDX(dim-1-j,i,dim)] = src[RIDX(i,j,dim)]; 
    return; 
}

目标：使用代码优化技术使旋转操作运行的更快

平滑操作

void naive_smooth(int dim, pixel *src, pixel *dst) { 
    int i, j; 
    for(i=0; i < dim; i++) 
    for(j=0; j < dim; j++) 
        dst[RIDX(i,j,dim)] = avg(dim, i, j, src); /* Smooth the (i,j)thpixel */ 
    return; 
}

目标：使用代码优化技术使平滑操作运行的更快

性能评判方法

CPE or Cycles per Element

如果一个函数使用C个周期去执行一个大小为N*N的图像，那么CPE=C/(N*N),因此CPE越小越好

如何定义函数

在kernel.c中有rotate的实现方法，我们需要添加自己的rotate实现，函数名自己命名，然后通过

void register_rotate_functions() { 
    add_rotate_function(&rotate, rotate_descr); 
    add_rotate_function(&my_rotate，my_rotate_descr）；
}

把自己实现的函数注册进去

编码规则

只能用ANSI C，不能用嵌入式汇编

不能修改测量时间的机制（CPE）

只能修改kernels.c，可以定义宏，全局变量，函数

旋转

在旋转过程中，源图像（src）的每一列被逆序复制到目标图像（dst）的每一行。因此，源图像的左上角（src[0]）被复制到目标图像的左下角（dst[0]），源图像的第二列的顶部（src[dim]）被复制到目标图像的第二行的底部（dst[1]），以此类推。

这是通过以下步骤完成的：

  1. 初始时，dst指针被移动到目标图像的底部（dst += (dim * dim - dim)）。

  2. 然后，开始两层循环。外层循环按32像素的步长遍历源图像的列（i）；内层循环遍历每列的所有像素（j）。

  3. 在内层循环中，源图像的每一列（src[i]）被逆序复制到目标图像的对应行（dst[j]）。这是通过将src的当前元素复制到dst的当前元素，然后递增src指针（src++）并递减dst指针（dst -= dim）实现的。这样，dst指针总是指向目标图像的上一行，而src指针总是指向源图像的下一列。

  4. 在外层循环的每次迭代结束时，src和dst指针都被调整，以便在下一次迭代中处理源图像的下一组32列和目标图像的下一组32行。

因此，这段代码实现了将源图像旋转90度并复制到目标图像的功能。

/*
 * rotate - Your current working version of rotate
 * IMPORTANT: This is the version you will be graded on
 */
char rotate_descr[] = "rotate: Current working version";
void rotate(int dim, pixel *src, pixel *dst)
{
    // naive_rotate(dim, src, dst);
    int i, j;
    dst += (dim * dim - dim); // dst指针被移动到目标图像的底部
    for (i = 0; i < dim; i += 32)
    {
        for (j = 0; j < dim; j++)
        {
            dst[0] = src[0];
            dst[1] = src[dim];
            dst[2] = src[2 * dim];
            dst[3] = src[3 * dim];
            dst[4] = src[4 * dim];
            dst[5] = src[5 * dim];
            dst[6] = src[6 * dim];
            dst[7] = src[7 * dim];
            dst[8] = src[8 * dim];
            dst[9] = src[9 * dim];
            dst[10] = src[10 * dim];
            dst[11] = src[11 * dim];
            dst[12] = src[12 * dim];
            dst[13] = src[13 * dim];
            dst[14] = src[14 * dim];
            dst[15] = src[15 * dim];
            dst[16] = src[16 * dim];
            dst[17] = src[17 * dim];
            dst[18] = src[18 * dim];
            dst[19] = src[19 * dim];
            dst[20] = src[20 * dim];
            dst[21] = src[21 * dim];
            dst[22] = src[22 * dim];
            dst[23] = src[23 * dim];
            dst[24] = src[24 * dim];
            dst[25] = src[25 * dim];
            dst[26] = src[26 * dim];
            dst[27] = src[27 * dim];
            dst[28] = src[28 * dim];
            dst[29] = src[29 * dim];
            dst[30] = src[30 * dim];
            dst[31] = src[31 * dim];
            src++;      // src指针指向源图像的下一列
            dst -= dim; // dst指针指向目标图像的上一行
        }
        // 源图像的下一组32列
        src += 31 * dim;
        // 目标图像的下一组32行
        dst += dim * dim + 32;
    }
}

平滑

smooth函数的目标是通过对每个像素及其邻近像素的平均值来“平滑”图像，因为它降低了像素与像素之间颜色的突变，使得图像的颜色变得更为均匀。其中涉及到处理图像边界（角落和边缘）的特殊情况，因为这些像素的邻近像素较少。对于图像的其他部分，smooth会计算每个像素及其8个邻居的平均值，并将该平均值分配给输出图像的相应像素。

/*
 * smooth - Your current working version of smooth.
 * IMPORTANT: This is the version you will be graded on
 */
char smooth_descr[] = "smooth: Current working version";
void smooth(int dim, pixel *src, pixel *dst)
{
    // naive_smooth(dim, src, dst);
    int i, j, myJ;

    // 处理四个角
    dst[0].red = (src[0].red + src[1].red + src[dim].red + src[dim + 1].red) >> 2;
    dst[0].blue = (src[0].blue + src[1].blue + src[dim].blue + src[dim + 1].blue) >> 2;
    dst[0].green = (src[0].green + src[1].green + src[dim].green + src[dim + 1].green) >> 2;

    i = dim * 2 - 1;
    dst[dim - 1].red = (src[dim - 2].red + src[dim - 1].red + src[i - 1].red + src[i].red) >> 2;
    dst[dim - 1].blue = (src[dim - 2].blue + src[dim - 1].blue + src[i - 1].blue + src[i].blue) >> 2;
    dst[dim - 1].green = (src[dim - 2].green + src[dim - 1].green + src[i - 1].green + src[i].green) >> 2;

    j = dim * (dim - 1);
    i = dim * (dim - 2);
    dst[j].red = (src[j].red + src[j + 1].red + src[i].red + src[i + 1].red) >> 2;
    dst[j].blue = (src[j].blue + src[j + 1].blue + src[i].blue + src[i + 1].blue) >> 2;
    dst[j].green = (src[j].green + src[j + 1].green + src[i].green + src[i + 1].green) >> 2;

    j = dim * dim - 1;
    i = dim * (dim - 1) - 1;
    dst[j].red = (src[j - 1].red + src[j].red + src[i - 1].red + src[i].red) >> 2;
    dst[j].blue = (src[j - 1].blue + src[j].blue + src[i - 1].blue + src[i].blue) >> 2;
    dst[j].green = (src[j - 1].green + src[j].green + src[i - 1].green + src[i].green) >> 2;

    // 处理四个边
    // 上
    i = dim - 1;
    for (j = 1; j < i; j++)
    {
        dst[j].red = (src[j].red + src[j - 1].red + src[j + 1].red + src[j + dim].red + src[j + 1 + dim].red + src[j - 1 + dim].red) / 6;
        dst[j].green = (src[j].green + src[j - 1].green + src[j + 1].green + src[j + dim].green + src[j + 1 + dim].green + src[j - 1 + dim].green) / 6;
        dst[j].blue = (src[j].blue + src[j - 1].blue + src[j + 1].blue + src[j + dim].blue + src[j + 1 + dim].blue + src[j - 1 + dim].blue) / 6;
    }

    // 下
    i = dim * dim - 1;
    for (j = i - dim + 2; j < i; j++)
    {
        dst[j].red = (src[j].red + src[j - 1].red + src[j + 1].red + src[j - dim].red + src[j + 1 - dim].red + src[j - 1 - dim].red) / 6;
        dst[j].green = (src[j].green + src[j - 1].green + src[j + 1].green + src[j - dim].green + src[j + 1 - dim].green + src[j - 1 - dim].green) / 6;
        dst[j].blue = (src[j].blue + src[j - 1].blue + src[j + 1].blue + src[j - dim].blue + src[j + 1 - dim].blue + src[j - 1 - dim].blue) / 6;
    }

    // 右
    for (j = dim + dim - 1; j < dim * dim - 1; j += dim)
    {
        dst[j].red = (src[j].red + src[j - 1].red + src[j - dim].red + src[j + dim].red + src[j - dim - 1].red + src[j - 1 + dim].red) / 6;
        dst[j].green = (src[j].green + src[j - 1].green + src[j - dim].green + src[j + dim].green + src[j - dim - 1].green + src[j - 1 + dim].green) / 6;
        dst[j].blue = (src[j].blue + src[j - 1].blue + src[j - dim].blue + src[j + dim].blue + src[j - dim - 1].blue + src[j - 1 + dim].blue) / 6;
    }

    // 左
    i = i - (dim - 1);
    for (j = dim; j < i; j += dim)
    {
        dst[j].red = (src[j].red + src[j - dim].red + src[j + 1].red + src[j + dim].red + src[j + 1 + dim].red + src[j - dim + 1].red) / 6;
        dst[j].green = (src[j].green + src[j - dim].green + src[j + 1].green + src[j + dim].green + src[j + 1 + dim].green + src[j - dim + 1].green) / 6;
        dst[j].blue = (src[j].blue + src[j - dim].blue + src[j + 1].blue + src[j + dim].blue + src[j + 1 + dim].blue + src[j - dim + 1].blue) / 6;
    }

    // 处理中间部分
    myJ = dim;  // 第二行的第一个元素

    for (i = 1; i < dim - 1; i++)
    {
        for (j = 1; j < dim - 1; j++)
        {
            myJ++;
            dst[myJ].red = (src[myJ - 1].red + src[myJ].red + src[myJ + 1].red + src[myJ - dim - 1].red + src[myJ - dim].red + src[myJ - dim + 1].red + src[myJ + dim - 1].red + src[myJ + dim].red + src[myJ + dim + 1].red) / 9;
            dst[myJ].green = (src[myJ - 1].green + src[myJ].green + src[myJ + 1].green + src[myJ - dim - 1].green + src[myJ - dim].green + src[myJ - dim + 1].green + src[myJ + dim - 1].green + src[myJ + dim].green + src[myJ + dim + 1].green) / 9;
            dst[myJ].blue = (src[myJ - 1].blue + src[myJ].blue + src[myJ + 1].blue + src[myJ - dim - 1].blue + src[myJ - dim].blue + src[myJ - dim + 1].blue + src[myJ + dim - 1].blue + src[myJ + dim].blue + src[myJ + dim + 1].blue) / 9;
        }

        // 跳过这一行的最后一个像素和下一行的第一个像素
        myJ += 2;
    }
}

运行时要将kernels.c文件中的以下三处修改为自己的信息

然后依次执行

make driver
./driver

 

青衫客36
关注
专栏目录
csapp perflab
06-22
计算机体系结构的performance lab，分数为17.8和22.2，可直接使用
CSAPP实验四：性能优化实验（Perflab）
热门推荐
CNFINITE的博客
08-12 1万+
本系列文章为中国科学技术大学计算机专业学科基础课《计算机系统》布置的实验，上课所用教材和内容为黑书CSAPP，当时花费很大精力和弯路，现来总结下各个实验，本文章为第四个实验——性能优化实验（Perflab）。 一、实验名称：perflab 二、实验学时： 3 三、实验内容和目的： 此次实验进行图像处理代码的优化。图像处理提供了许多能够通过优化而得到改良的函数。在此次实验中，我们将考虑两种图像处理操作：roate， 此函数用于将图像逆时针旋转90°；以及smooth，对图像...
【计算机系统】 PerfLab优化理论到实践
...
10-22 1767
PerfLab 优化方法目录 常数除法的自动优化 减少函数的调用 函数优化思路： 3.1 查表 3.2 求余 3.3 平方 3.4 用移位实现乘除法运算 3.5 避免不必要的整数乘法 3.6 使用增量和减量操作符 3.7 使用复合赋值表达式 3.8 公共表达式的提取 3.9 调整数据类型对齐方式 3.10 本地变量排列优化 3.11 指针变量局部化 3.12 不定义不...
perflab实验报告
06-12
perflab——代码性能优化，兼顾算法原型的理解，学会以底层的角度对抽象计算作最大限度的优化。
CSAPP：PerfLab实验
lilian的博客
04-05 7310
目录前言PartA优化一PartA优化二PartA优化三PartB优化一PartB优化二PartB优化三 前言 本实验是《深入理解计算机系统》一书中的附带实验。在本实验中，学生们必须优化应用程序的核心函数（如卷积积分或矩阵转置）的性能。这个实验非常清晰地表明了高速缓存地特性，并带给学生们低级程序优化的经验。 本文用于记录之前做实验的一些信息，可能思路有些凌乱，谨慎参考！ 常用的几种代码优化的思路：...
中科大csapp实验4 perflab-handout 代码优化
01-07
中科大程序设计与计算机系统，实验4，代码优化，亲测可用，版本优化相当高
ics lab8 perflab性能优化实验
10-31
自己写的csapp上的性能优化实验的kernels.c。
csapp lab archlab 解答
06-21
《csapp lab archlab 解答》 在计算机科学领域，CSAPP（《计算机系统：一个程序员的视角》）是一本非常重要的教材，它深入浅出地介绍了计算机系统的底层原理。Lab Archlab是该书中的一个重要实验，旨在让学生通过...
CSAPP_LAB:CSAPP实验
03-09
在"CSAPP_LAB-master"这个目录下，可能包含了实验的源代码、指导文档、测试数据以及解决方案等资源。通过逐步完成每个实验，学生不仅可以巩固CSAPP书中的理论知识，还能提升实际编程技能，为未来在计算机领域的深入...
csapp——perflab解题报告
qq_32464727的博客
12-26 4328
csapp——perflab解题报告 需求分析： 需要优化的函数有两个 rotate 和 smooth,CPE 值越低越好，mean综合评分越高越好 基本的程序优化方法： 避免循环内部的乘(除)法以及冗余计算 避免循环内部有过多依赖和跳转，使cpu能流水起来 空间换时间最经典的就是查表法了，某些计算相当耗时，但其自变量的值域是比较有限的，这样的情况可以预先计算好每个自变量对应的函数值，存在一个表格中，每次根据自变量的　　值去索引对应的函数值即可（强烈推荐） 预分配内存 实验题目中文翻译版本 本次实验中，
湖南大学计算机组成与结构perflab实验源码及报告
10-01
湖南大学计算机组成与结构perflab实验源码及报告
csapp实验6-perflab实验详解
最新发布
m0_65591847的博客
08-16 583
csapp的第六个perflab实验，实验很粗糙，我做的也很粗糙，感觉意义不大
深入理解计算机系统——实验 Perflab
悲伤无声地涌出来
04-06 8331
一、前言 1、对程序进行优化时要使优化后得到的程序和未优化的版本有一样的行为。 2、不依赖与目标机器的的特性的常见代码优化方法有：消除循环的低效率、减少过程调用、消除不必要的存储器引用 3、这次实验主要对两个函数进行优化，rotate函数和smooth函数 rotate函数要求将二维矩阵逆时针旋转90度 smooth函数要求将二维矩阵中每个元素的值替换为周围相邻元素的算术平均值 4、To...
PerfLab（直接在服务器上完成）
weixin_43320890的博客
12-08 1277
PerfLab 性能优化实验（直接在服务器上完成） 1.实验前的准备 1.1 登录服务器：打开cmd，输入指令ssh 49.123.112.130 -用户名 1.2 初始化：输入指令perf_init（初始化只需要在第一次登陆时操作，以后如果再次初始化会将自己所做的所有修改清空） 1.3 打开目录，输入指令：cd perfLab 2. 修改Makefile文件 2.1 输入指令vim Makefile ...
perflab实验日志二
imotolove的博客
04-11 4046
一、实验内容 1、通过改写rotate和smooth函数，对程序进行优化，最后通过查看加速比和cep 得出最终的结果，cep越小越好，加速比越大越好 二、实验步骤 1、rotate优化 优化1 牺牲读命中来减少写不命中惩罚 原来的rotate函数是一行行读，然后一列列写来达到旋转的目的 其中RIDX(i,j,n)= ((i)*(n)+(j))，考虑dim等于2的最简单情况，按照循...
perflab优化1
qq_43723613的博客
03-29 1193
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、 学习图像旋转与图像...
perflab实验smooth函数前缀和优化
One of thre_tigers的博客
05-18 1412
实验内容 本次实验要求修改kernel.c中的smooth函数，优化其加速比。 优化策略 优化策略：使用前缀和避免不必要的重复计算 前缀和算法本次实验慎用，不一定符合实验的要求，在实验要求范围内的改进才被认作是好的改进，虽然你的算法达到了50.3的加速比！这里将虽然没有改动avg但是其实是变相的改变了avg的均值算法。 优化思路 刚开始拿到smooth优化时，想了很多方法，包括避免函数调用，分...
深入理解计算机系统CSAPP-perfLab：kernels.c性能优化实验：smooth优化详细实验日志（含四个优化版本）
乔卿的博客
11-08 9567
目录一、实验内容二、相关知识1、 平滑处理流程2、 平滑计算过程1) 四个顶点2) 除顶点外的四条边上的像素点3) 其他像素点3、 服务器与本地计算机之间复制文件的方法1) 把本地文件拷贝到服务器2) 把服务器文件拷贝到本地计算机4、 常见性能优化方法5、 Makefile规则6、64位系统中RGB像素点(结构体)的存储7、 数组在内存中的存储原理三、实验步骤四、 程序优化各个版本写在前面1、 添...
南京大学CSAPP Lab 5-9：ELF加载与监控实验详解
南京大学计算机科学与技术系的《计算机系统基础》课程实验手册，专注于lab5-9，即"ELF加载与监控"。该实验旨在帮助学生深入理解ELF（Executable and Linkable Format）可执行文件格式，并通过编写一个简单的静态链接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青衫客36

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值