【无标题】

已于 2022-12-13 10:58:09 修改
阅读量269 收藏 1
点赞数
文章标签： 算法 c++ java
于 2022-12-13 10:57:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/last_cancel/article/details/128297817
版权

chushibanben

chushidaima

 

 

 

 

 

 

 

 

 

 

 

 

 

/********************************************************
 * Kernels to be optimized for the CS:APP Performance Lab
 ********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include "defs.h"

/* 
 * Please fill in the following team struct 
 */
team_t team = {
    "sztu",              /* Team name */

    "cxs",     /* First member full name */
    "1583312039@qq.com",  /* First member email address */

    "",                   /* Second member full name (leave blank if none) */
    ""                    /* Second member email addr (leave blank if none) */
};

/***************
 * ROTATE KERNEL
 ***************/

/******************************************************
 * Your different versions of the rotate kernel go here
 ******************************************************/

/* 
 * naive_rotate - The naive baseline version of rotate 
 */
char naive_rotate_descr[] = "naive_rotate: Naive baseline implementation";
void naive_rotate(int dim, pixel *src, pixel *dst) 
{
int i, j;
//src初始化为第一行第一个像素点，dst与之对应，应指向最后一行第一个像素点
dst += (dim-1)*dim;
for (i = 0; i < dim; i+=32){ 
	for (j = 0; j < dim; j++){ 
		//循环展开，共32：
		*dst=*src; src+=dim; dst+=1;
        *dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src; src+=dim; dst+=1;
		*dst=*src;
		//注意修改src与dst指向的位置，改为下一列的相应32行
		src++;
		src-= (dim<<5)-dim; 
		dst-=31+dim;
	}
	dst+=dim*dim;
	dst+=32;
	src += (dim<<5)-dim;
}

}

/* 
 * 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);
}

/*********************************************************************
 * register_rotate_functions - Register all of your different versions
 *     of the rotate kernel with the driver by calling the
 *     add_rotate_function() for each test function. When you run the
 *     driver program, it will test and report the performance of each
 *     registered test function.  
 *********************************************************************/

void register_rotate_functions() 
{
    add_rotate_function(&naive_rotate, naive_rotate_descr);   
    add_rotate_function(&rotate, rotate_descr);   
    /* ... Register additional test functions here */
}


/***************
 * SMOOTH KERNEL
 **************/

/***************************************************************
 * Various typedefs and helper functions for the smooth function
 * You may modify these any way you like.
 **************************************************************/

/* A struct used to compute averaged pixel value */
typedef struct {
    int red;
    int green;
    int blue;
    int num;
} pixel_sum;

/* Compute min and max of two integers, respectively */
static int min(int a, int b) { return (a < b ? a : b); }
static int max(int a, int b) { return (a > b ? a : b); }

/* 
 * initialize_pixel_sum - Initializes all fields of sum to 0 
 */
static void initialize_pixel_sum(pixel_sum *sum) 
{
    sum->red = sum->green = sum->blue = 0;
    sum->num = 0;
    return;
}

/* 
 * accumulate_sum - Accumulates field values of p in corresponding 
 * fields of sum 
 */
static void accumulate_sum(pixel_sum *sum, pixel p) 
{
    sum->red += (int) p.red;
    sum->green += (int) p.green;
    sum->blue += (int) p.blue;
    sum->num++;
    return;
}

/* 
 * assign_sum_to_pixel - Computes averaged pixel value in current_pixel 
 */
static void assign_sum_to_pixel(pixel *current_pixel, pixel_sum sum) 
{
    current_pixel->red = (unsigned short) (sum.red/sum.num);
    current_pixel->green = (unsigned short) (sum.green/sum.num);
    current_pixel->blue = (unsigned short) (sum.blue/sum.num);
    return;
}

/* 
 * avg - Returns averaged pixel value at (i,j) 
 */
static pixel avg(int dim, int i, int j, pixel *src) 
{
    int ii, jj;
    pixel_sum sum;
    pixel current_pixel;

    initialize_pixel_sum(&sum);
    for(ii = max(i-1, 0); ii <= min(i+1, dim-1); ii++) 
	for(jj = max(j-1, 0); jj <= min(j+1, dim-1); jj++) 
	    accumulate_sum(&sum, src[RIDX(ii, jj, dim)]);

    assign_sum_to_pixel(&current_pixel, sum);
    return current_pixel;
}

/******************************************************
 * Your different versions of the smooth kernel go here
 ******************************************************/

/*
 * naive_smooth - The naive baseline version of smooth 
 */
char naive_smooth_descr[] = "naive_smooth: Naive baseline implementation";
void naive_smooth(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;
}



/*
 * 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);
}


/********************************************************************* 
 * register_smooth_functions - Register all of your different versions
 *     of the smooth kernel with the driver by calling the
 *     add_smooth_function() for each test function.  When you run the
 *     driver program, it will test and report the performance of each
 *     registered test function.  
 *********************************************************************/

void register_smooth_functions() {
    add_smooth_function(&smooth, smooth_descr);
    add_smooth_function(&naive_smooth, naive_smooth_descr);
    /* ... Register additional test functions here */
}

陈晓树
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
CSAPP LAB---perflab-handout性能优化
The_V_的博客
07-11 1万+
LAB4 1. Naive_rotate 1.1原始代码分析 /* *naive_rotate - The naive baseline version of rotate */ char naive_rotate_descr[] ="naive_rotate: Naive baseline implementation"; void naive_rotate(int dim, pixe
CSAPP perfab
weixin_43409270的博客
08-10 419
CSAPP perfab Part A rotate实验，把nxn的正方形图片逆时针旋转90度，这是一个内存敏感的程序，优化的主要思路是分块（和cachelab很像）。由于图片的边长都是32的倍数，所以我们选择块大小为4，8，16，32去尝试哪一种性能更好，最终选择为16x16的块 Part B smooth实验，这是一个计算敏感的程序，优化的主要思路是： 1、去掉不必要的过程调用：可以看到，为了处理边缘点，原程序用了很多min和max判断 好处就是代码简洁，坏处就是影响性能CPE。我们分别处理4个角点，
CSAPP：Perflab
weixin_42559124的博客
05-28 552
perflab 要干啥？ 重写kernels.c中的rotate.c与smooth函数使之更快。 怎么干？ rotate.c 无法循环展开因为这道题每一步都在寻址，并且寻址的目标每一步都不相同，并且在一个地址的值一次就赋值完毕，不会对同一个地址进行二次寻址，所以我想的改进方向就是使得寻址更加快速。所以我使得寻址的地址更加连续。改进如下： void rotate(int dim, pixel *src, pixel *dst) { int i, j, t,n; n = dim ...
csapp——perflab解题报告
qq_32464727的博客
12-26 4274
csapp——perflab解题报告 需求分析： 需要优化的函数有两个 rotate 和 smooth,CPE 值越低越好，mean综合评分越高越好 基本的程序优化方法： 避免循环内部的乘(除)法以及冗余计算 避免循环内部有过多依赖和跳转，使cpu能流水起来 空间换时间最经典的就是查表法了，某些计算相当耗时，但其自变量的值域是比较有限的，这样的情况可以预先计算好每个自变量对应的函数值，存在一个表格中，每次根据自变量的　　值去索引对应的函数值即可（强烈推荐） 预分配内存 实验题目中文翻译版本 本次实验中，
非参数估计-高斯核平滑Gaussian kernel smoothing-非参数密度估计
热门推荐
qq_41103204的博客
03-09 2万+
目录1 概念1.1 核平滑的概念和计算1.2 Nadaraya-Watson回归1.3 高斯核2 高斯核平滑过程-Python实现2.1 加载库和生成数据2.2 Full Width at Half Maximum (FWHM)2.3 分步进行平滑2.4 二维平滑2.5 为什么要进行平滑 1 概念 1.1 核平滑的概念和计算 核平滑是一种用来估计实值方程的统计方法，来作为周围观察数据的加权平均值。...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
delphi 无标题调整大小
11-26
在Delphi编程环境中，"无标题调整大小"通常是指创建没有标准标题栏的窗口，并允许用户通过拖动边界来调整其大小。这种设计通常用于自定义界面或创建无边框的对话框。以下是对这个主题的详细解释： 一、创建无标题...
HNU计算机系统试验perflab1
君陌的博客
10-27 2938
此为本人在做实验时所记载的实验日志，仅供参考。 代码一： void naive_rotate1(int dim,pixel *src,pixel *dst){ int i,j,tmp;//设置一个中间变量tmp，用来存储中间值 for(j=0;j<dim;j++){ tmp=dim-1-j;//由于dim-1-j会经常使用，所以这里进行提前计算，省去了每次计算的时间 ...
深入理解计算机系统 perflab 程序性能优化实验
syq1207的博客
05-31 1万+
自从上次实验3bomb已经过去很久了，昨天周六下午刚刚验收完所带班级的必做实验的最后两个，最近一直很忙，也没有来更新了，其实不是最近应该是每天都好忙，最近一直还在看论文做实验。 验收前周五拿出时间来看了一下最后两个必做实验。一个是perflab，性能实验，这个实验主要是考察的课本中的第五章的程序优化的一些知识，通过优化程序的核函数，然后来对比自己和原始函数的CPE和加速比。 这个实验主要考虑一
CSAPP LAB4 perflab-handout性能优化 smooth负优化详解
qq_21398713的专栏
05-15 6728
在优化代码之前，首先要知道我们有哪些方法可以优化性能? 翻书！把教材翻到目录，第五章赫然写着优化方法： 1、使用内联函数。一种替换代码方法，尽可能减少函数调用； 2、消除循环中的低效率。比如说for循环判断里面带了个函数，那么就属于低效率的循环，从时间复杂度上面也能分析； 3、减少过程调用。比如说经常需要先取数，再操作，那么优化的方法通常是把这些数安排在连续的地址里面，这样可以减少地址的计
Exploratory Data Analysis (EDA) -- 非参数估计
eveiii的博客
09-06 588
Exploratory Data Analysis1. Histograms 直方图2. Non-parametric Density Estimation3. Kernel density estimation (KDE) 核密度估计3.1 Parzen Windows3.2 Smooth Kernel4. Multivariate Density Estimation 多元密度估计5. Transformation Kernel Density Estimation (TKDE) 1. Histogra
深入理解计算机系统CSAPP-perfLab：kernels.c性能优化实验：smooth优化详细实验日志（含四个优化版本）
乔卿的博客
11-08 9534
目录一、实验内容二、相关知识1、 平滑处理流程2、 平滑计算过程1) 四个顶点2) 除顶点外的四条边上的像素点3) 其他像素点3、 服务器与本地计算机之间复制文件的方法1) 把本地文件拷贝到服务器2) 把服务器文件拷贝到本地计算机4、 常见性能优化方法5、 Makefile规则6、64位系统中RGB像素点(结构体)的存储7、 数组在内存中的存储原理三、实验步骤四、 程序优化各个版本写在前面1、 添...
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3219
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
算法 —— 暴力枚举
fen_0108的博客
07-25 3818
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
2024.7.24 作业
qq_64434282的博客
07-24 2559
【代码】2024.7.24 作业。
嵌入式初学-C语言-七
最新发布
MaBaB的博客
07-29 524
分支结构 分支结构：又被称之为选择结构 概念 选择结构：根据条件成立与否，选择相应的操作。
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值