2023年perflab实验报告新编

曲埼大室

HUNANUNIVERSITY

湖南大学课程实验报告

课程名称：计算机组成与结构

实验项目名称：。perf1ab

专业班级：__________________________________

姓名:___________________________________

学号：____________________________________

指导教师:_________________________________

完成时间：2023年05月22日

计算机科学与工程系

实验题目：程序性能调优实验

实验目的：

kerne1.c文献中重要有两个需要进行优化的函数：rotate和smooth,并分别给出了naive_rot

ate和naive_smooth两个函数的基本实现作为base1ine作为你改善后的程序的比较对象。你

需要读懂r。tate和smooth函数，并对其进行优化。你每写一个新版本的、优化的rotate和

smooth函数，均可在成注册后使用driver进行测试，并得到相应的CPE和加速比。本次实验，

规定针对每个函数、每个人均至少写出3种优化版本、并根据driver报告的结果进行性能分析。

实验环境:

Vmware虚拟机ubuntul2.041inux终端

实验环节和结果分析：

函数源码：

rotate函数：

voidnaive_rotate(intdim,pixe1*src,pixel*dst)

(

inti,j；

for(i=0;i<dim;i++)

»for(j=0;j<dim;j++)

°dst[RIDX(dim-1—j,i,dim)J=src[RIDX(i,j,dim)]；

)

rotate函数的作用是通过将每个像素进行行列调位，将一副点阵图像进行90度旋转。其中RI

DX(i,j,n)即(⑴*(n)+(j))。函数缺陷为程序局部性不好，循环次数过多。可以对其进行分块来提高

空间局部性，也可以进行循环展开。

smooth函数：

voidnaive_smooth(intdim,pixel*src,pixel*dst)

{

inti,j;

for(i=0;i<dim;i++)

»for(j=0;j<dim;j++)

sdstIRIDX(i,j,dim)J=avg(dim,i,j,src);

)

smooth函数的作用是通过对•图像每儿点像素求平均值来对图像进行模糊化解决。函数缺陷

是循环次数过多和频繁调用avg函数，avg函数中又包含许多函数。应当减少avg函数的调用次

数，且进行循环展开。

第一种版本：

CPE分析：

Activities-Terminal▼Fri04:31

sunlight@ubuntu:"

FileEditViewSearchTerminalHelp

gcc-Wall-02-m32-c-okernels.©kernels.c

gcc-Wall-02-m32-c-ofcyc.ofcyc.c

gcc-Wall-02-m32-c-oclock.oclock.c

gcc-Wall-02-m32driver.okernels.ofcyc.oclock.o-Im-odriver

sunltght@ubuntu:~$./driver

Teamname:sunlight

Member1:suncy

Email1:suncy@126.com

Rotate:Version=naive__rotate:Naivebaselineimplementation:

Dim641282565121024Mean

YourCPEs24.133.3

BaselineCPEs14.740.146.465.994.5

Speedup

Rotate:Version=rotate:Currentworkingversion:

Dim641282565121024Mean

YourCPEs8.611.0

BaselineCPEs14.740.146.465.994.5

Speedup4.58.68.0

Smooth:Version=smooth:Currentworkingversion:

Dim3264128256512Mean

YourCPEs28.329.835.144.558.6

BaselineCPEs695.6698.0762.0717.0722.0

Speedup24.523.426.e16.112.318.7

Smooth:Version=naive_smooth:Naivebaselineimplementation:

Dim32一64128256512Mean

YourCPEs58.955.859.658.162.8

BaselineCPEs695.0698.0702.0717.0722.0

Speedup11.812.511.812.311.512.e

SummaryofYourBestScores:

Rotate:8.0(rotate:Currentworkingversion)

Smooth:18.7(smooth:Currentworkingversion)

sunltght@ubuntu:~$口

rotate函数：

voidrotate(intdim,pixel*src,pixel*dst)

(

inti,j,iijj;

for(ii=0;ii<dim;ii+=4)

for(jj=O;jj<dim;jj+=4)

for(i=ii；i<ii+4；i++)

for(j=jj；j<jj+4;j++)

dst[RIDX(dim-l-j,i,dim)]=src[RIDX(i,j.dim)]；

)

多添加了两个for函数,将循环提成了4*4的小块，在cache存储体局限性够大的情况下，对循

环分块可以提高高速缓存命中率，从高提高了空间局部性。从测试的CPE中也可以看出，在dim

是64的时候，原代码和本代码CPE相差不大,而随着dim的增大，本代码CPE增长不大，而原代码

CPE急剧增长，就是受到了cache存储的局限性。

smooth函数：

voidsmooth(intdim,pixel*src,pixel*dst)

pixelsumrowsum[530][530];

inti,j,snum;

for(i=0；i<dim；i++)

(

rowsum[i][0].red=(src[RIDX(i,0,dim)].red+src[RIDX(i,l,dim)].

red);

rowsum[iJIOJ.blue=(src[RIDX(i,0,dim)].blue+src[RIDX(i,1,

dim)].b1ue);

rowsum[i][0].green=(src[RIDX(i,0,dim)].green+src[RIDX(i,1,d

im)].green);

rowsum[i][0].num=2;

for(j=l；j<dim-l;j++)

(

rowsum[i][j].red=(src[RIDX(i,j—1,dim)],red+src[RI

DX(i,j,dim)].red+src[RIDX(i,j+1,dim)].red);

rowsumfi]Ej].b1ue=(srcERIDX(i,j-1,dim)].blue+srcfRIDX(i,

j,dim)].blue+src[RIDX(i,j+Ldim)],blue);

rowsum[i][j].green=(src|RIDX(i,j-1,dim)J.green+src|RID

X(i,j,dim)].green+src[RIDX(i,j+1,dim)].green);

rowsum[i][j].num=3;

)

rowsum[i][dim—1].red=(src[RIDX(i,dim-2,dim)].red+src[RIDX

(i,dim-1,dim)].red);

rowsum[i][dim-l].b1ue=(src[RIDX(i,dim-2,dim)],b1ue+src[R

IDX(i,dim-1,dim)J.blue)；

rowsum[i][dim-1].green=(src[RIDX(i,dim—2,dim)],green+src

fRIDX(i,dim-1,dim)].green);

rowsum[i][dim—1].num=2；

)

for(j=0;j<dim；j++)

(

snum=rowsum[0J|j].num+rowsum[l]|j].num；

dst[RIDX(0,j,dim)].red=(unsignedshort)((rowsumEO][j].r

ed+rowsum[l][j].red)/snum);

dst[RIDX(0,j,dim)]blue=(unsignedshort)((rowsum[0][j].blue+ro

wsum[l][jj.blue)/snum);

dst[RIDX(0,j,dim)].green=(unsignedshort)((rowsumgreen

+rowsum[l][j].green)/snum);

for(i=1；i<dim-1；i++)

(

snum=rowsum[i-l][j].num+rowsum[i][j].num+rowsum[i+1][j].nu

m；

dst|RIDX(i,j,dim)].red=(unsignedshort)((rowsum[i-1]

Lj].red+rowsum[i]Lj].red+rowsum[i+1][j].red)/snum);

dstIRIDX(i,j,dim)J.b1ue=(unsignedshort)((rowsum

Li-1][j].blue+rowsum[i][jJ.blue+rowsum[i+l]|jj.b1ue)/snum);

dst[RIDX(i,j,dim)].green=(unsignedshort)((rowsum[i-1][j].gre

en+rowsum[i][j].green+rowsum[i+1][j].green)/snum);

}

snum=rowsum[dim—l][jl.num+rowsum[dim-2][j].num;

dst[RIDX(dim—1,j,dim)].red=(unsignedshort)((rowsum

[dim-2][j].red+rowsum[dim-1][j].red)/snum);

dst[RIDX(dim—1,j,dim)].b1ue=(unsignedshort)((rowsum[dim—

2][j].blue+rowsum[dim-1][j].b1ue)/snum);

dst[RIDX(dim-1,j,dim)].green=(unsignedshort)((rowsumfdi

m-2][j].green+rowsum[digreen)/snum);

)

)

本函数取消调用了avg函数，通过在函数中直接对像素点的三原色比例分别求平均值的方法

来求像素的平均值。由于取消『avg函数的调用，减少了大多数函数调用环节，并且将反复运用的

数据储存在了数组之中，因此提高了速度。但是本方法提高的速度不够显著。仅是在dim较小的

情况下才有较好的优化。且当dim>512时，超过了设立的数组大小会报错。

第二种版本：

CPE分析：

Activities|^TerminalvFri04:33

sunlight@ubuntu:"

FileEditViewSearchTerminalHelp

A

gcc-Wall-02-m32-c-ofcyc.ofcyc.c

gcc-Wall-02-m32-c-oclock.oclock.c

gcc-Wall-02-m32driver.okernels.ofcyc.oclock.o-Im-odriver

sunltght0ubuntu:~$./driver

Teamname:sunlight

Member1:suncy

Email1:suncy@126.com

Rotate:Version=naive__rotate:Naivebaselineimplementation:

Dim641282565121624Mean

YourCPEs24.633.2

BaselineCPEs14.740.146.465.994.5

Speedup5.02.95.1

Rotate:Version=rotate:Currentworkingversion:

Dim641282565121024Mean

YourCPEs4.17.6

BaselineCPEs14.740.146.465.994.5

Speedup15.912.412.7

Smooth:Version=smooth:Currentworkingversion:

Dim3264128256512Mean

YourCPEs36.528.729.029.930.5

BaselineCPEs695.0698.0702.0717.0722.0

Speedup22.824.324.223.923.623.8

Smooth:Version=natve__smooth:Naivebaselineimplementation:

Dim3264128256512Mean

YourCPEs59.255.855.957.259.3

BaselineCPEs695.0698.0702.e717.0722.0

Speedup11.712.512.612.512.212.3

SummaryofYourBestScores:

Rotate:12.7(rotate:Currentworkingversion)

Smooth:23.8(smooth:Currentworkingversion)

sunttght@ubuntu:~$口

rotate函数：

voidrotate(intdim,pixel*src,pixe1*dst)

(

inti,j;

inttemp;

intitjt；

intimjm；

for(jt=0;jt<dim;jt+=32)

(

jm=jt+32;

for(it=0；it<dim;it+=32)

{

im=it+32；

for(j=jt;j<jm;j++)

(

temp=dim-1-j;

for(i=it;i<it+32;i++)

dst[RIDX(temp,i,dim)]=src[RIDX(i,j,dim)];

)

}

)

}

return；

}

这个函数跟第一种版本有较大的相似,但是是提成了32*32的小块。提高的速度比第一种版

本多，这是由于32*32的小块充足运用了cache储存，减少了冷不命中率。假如再增大小块的大小

的话,也许由于超过/cache储存，成了和原码同样的情况，减少空间局部性。

smooth函数：

voidsmooth(intdim,pixe1*src,pixel*dst)

(

intdimO=dim;

intdiml=dim—1;

intdim2=dim-2；

pixel*P1,*P2,*P3；

pixel*dstl;

PI=src;

P2=Pl+dimO;

dst->red=(P1->red+(P1+1)—>red+P2—>red+(P2+!)->red)»2;

dst->green=(P1->green+(P1+1)—>green+P2—>green+(P2+1)->green)>>2;

dst->blue=(P1->b1ue+(P1+!)->blue+P2->blue+(P2+1)->b1ue)»2;

dst++；

for(i=l;i<diml；i++)

(

dst->red=(Pl->red+(P1+1)->red+(P1+2)->red+P2->red+(P2+1)->r

ed+(P2+2)->red)/6；

dst—>green=(Pl->green+(Pl+1)->green+(Pl+2)->green+P2->gr

een+(P2+1)->green+(P2+2)->green)/6;

dst->b1ue=(P1->blue+(Pl+l)->blue+(P1+2)->blue+P2->b1

ue+(P2+l)->blue+(P2+2)->blue)/6;

dst++;

P1++；

P2++；

}

dst—>red=(Pl->red+(P1+l)->red+P2—>red+(P2+1)—>red)»2;

dst->green=(P1->green+(P1+1)->green+P2->green+(P2+l)->green)»2;

dst—>blue=(Pl—>b1ue+(Pl+l)—>b1ue+P2->b1ue+(P2+1)->blue)»2;

dst++;

Pl=src;

P2=Pl+dimO;

P3=P2+dimO;

for(i=l;i<diml；i++)

(

dst->red=(P1->red+(P1+l)->red+P2->red+(P2+l)->red+P3->red

+(P3+1)->red)/6;

dst—>green=(Pl->green+(Pl+l)->green+P2—>green+(P2+1)—>

green+P3->green+(P3+l)->green)/6;

dst->blue=(P1—>blue+(P1+1)->blue+P2->blue+(P2+1)->blue+P3->b1ue+(P3+

1)->b1ue)/6;

dst++；

dstl=dst+l；

for(j=1;j<dim2;j+=2)

(

dst->red=(Pl->red+(P1+1)->red+(P1+2)—>red+P2—>red+(P

2+l)->red+(P2+2)->red+P3->red+(P3+1)->red+(P3+2)->red)/9;

dst->green=(P1->green+(Pl+l)->green+(Pl+2)->green+P2->gr

een+(P2+1)—>green+(P2+2)->green+P3—>green+(P3+l)->green+(P3+2)->green)/9;

dst->blue=(P1—>blue+(Pl+l)->b1ue+(P1+2)->blue

+P2->blue+(P2+l)->b1ue+(P2+2)—>blue+P3->b1ue+(P3+l)->blue+(P3+2)->bkie)/9;

dstl->red=((Pl+3)->red+(P1+l)->red+(Pl+2)->red+(P2+

3)->red+(P2+1)->red+(P2+2)—>red+(P3+3)->red+(P3+1)->red+(P3+2)—>red)/9;

dstl->green=((Pl+3)->green+(Pl+l)->green+(Pl+2)—>green+(P2

+3)->green+(P2+l)->green+(P2+2)->green+(P3+3)—>green+(P3+1)—>green+

(P3+2)—>green)/9;

dst1->b1ue=((Pl+3)->b1ue+(Pl+1)->blue+(P1+2)->b1ue+(P2+

3)->blue+(P2+l)->b1ue+(P2+2)->blue+(P3+3)->b1ue+(P3+1)->blue+(P3+2)

->blue)/9;

dst+=2;

dstl+=2；

Pl+=2;

P2+=2;

P3+=2；

)

for(;j<diml;j++)

(

dst—>red=(Pl->red+(Pl+l)->red+(Pl+2)->red+P2->red+(P2+1)->r

ed+(P2+2)—>red+P3->red+(P3+1)—>red+(P3+2)->red)/9；

dst—>green=(P1—>green+(P1+1)->green+(P1+2)->green+P2->gr

een4-(P2+1)->green+(P2+2)->green+P3—>green+(P3+1)->green+(P3+2)—>green)/9;

dst->blue=(Pl->b1ue+(P1+1)->blue+(P1+2)・>blue+P2—>blue+

(P2+l)->blue+(P2+2)->blue+P3->bhie+(P3+l)->blue+(P3+2)->blue)/9;

dst++；

P1++;

P2++；

P3++；

)

dst->red=(P1->red+(P1+1)—>red+P2->red+(P2+1)—>red+P3->red+(P3+

1)->red)/6;

dst—>green=(P1->green+(Pl+1)->green+P2->green+(P2+1)->green

+P3->green+(P3+l)->green)/6;

dst—>b1ue=(P1->b1ue+(P1+1)->blue+P2->blue+(P2+1)->blue+P3->b1

ue+(P3+l)->blue)/6;

dst++;

P1+=2;

P2+=2;

P3+=2;

)

dst->red=(P1->red+(Pl+l)->red+P2—>red+(P2+1)->red)>>2；

dst—>green=(P1—>green+(P1+1)—>green+P2->green+(P2+1)->green)»2;

dst—>blue=(Pl->blue+(Pl+1)->blue+P2->bIue+(P2+1)->blue)»2;

dst++;

for(i=l;i<diml；i++)

(

dst->red=(Pl->red+(P1+1)—>red+(P1+2)->red+P2—>red+(P2+l)->r

ed+(P2+2)->red)/6;

dst->green=(Pl->green+(Pl+l)—>green+(Pl+2)->green+P2—>gr

een4-(P2+])—>green+(P2+2)—>green)/6;

dst->b1ue=(Pl->b1ue+(P1+1)->b1ue+(Pl+2)->blue+P2->blue+(P2+l)->

blue+(P2+2)—>blue)/6;

dst++;

P1++；

P2++;

}

dst->red=(P1->red+(Pl+1)—>red+P2->red+(P2+1)->red)>>2;

dst->green=(Pl->green+(Pl+1)->green+P2->green+(P2+1)—>g

reen)»2;

dst—>blue=(P1->blue+(P1+1)—>blue+P2->b1ue+(P2+l)—>blue)»2;

)

这段代码也是通过不调用avg函数来加速程序。

将Smooth函数解决分为4块,一为主体内部，山9点求平均值;二为4个顶点，由4点求平均值;

三为四条边界，由6点求平均值。从图片的顶部开始解决，再上边界，顺序解决下来，其中在解

决左边界时,f。r循环解决一行主体部分,就是以上的代码。

第三种版本：

CPE分析:

-

IActivitiesITerminal▼Fri04:35

sunlight@ubuntu:"

FileEditViewSearchTerminalHelp

gcc-Wall-02-m32-c-oclock.oclock.c

gcc-Wall-02-m32driver.okernels.ofcyc.oclock.o-Im-odriver

sunlight@ubuntu:~$./dirver

bash:./dirver:Nosuchfileordirectory

sunlight@ubuntu:~$./driver

Teamname:sunlight

Member1:suncy

Email1:suncy@126.com

Rotate:Version=natve__rotate:Naivebaselineimplementation:

Dim64-1282565121624Mean

YourCPES23.532.5

BaselineCPEs14.740.146.465.994.5

Speedup

Rotate:Version=rotate:Currentworkingversion:

Dim641282565121024Mean

YourCPEs4.36.0

BaselineCPEs14.740.146.465.994.5

Speedup6.918.519.715.215.714.3

Smooth:Version=smooth:Currentworkingversion:

Dim3264128256512Mean

YourCPEs17.421.8

BaselineCPEs695.0698.0702.0717.6722.0

Speedup39.832.031.833.833.734.1

Smooth:Version=naive_smooth:Naivebaselineimplementation:

Dim32-64128256512Mean

YourCPEs56.256.256.957.961.4

BaselineCPEs695.0698.0702.0717.0722.0

Speedup12.412.412.312.411.812.3

SummaryofYourBestScores:

Rotate:14.3(rotate:Currentworkingversion)

Smooth:34.1(smooth:Currentworkingversion)

sunlight@ubuntu:*$口

rotate函数:

voidrotate(intdim,pixel*src,pixel*(1st)

{

inti,j；

intdst_base=(dim-1)*dim；

dst+=dst_base;

for(i=0;i<dim;i+=32)

(

for(j=0;j<dim;j++)

(

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim;

dst++；

*dst=*src；

src+=dim；

dst++；

*dst=*src;

src+=dim;

dst++;

*dst=*src；

src+=dim；

dst++;

*dst=*src；

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++；

*dst=*src；

src+=dim;

dst++;

*dst=*src；

src+=dim;

dst++;

*dst=*src；

src+=dim;

dst++;

*dst=*src；

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++；

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src；

src+=dim;

dst++；

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src+=dim;

dst++；

*dst=*src；

src4-=dim;

dst++；

*dst=*src；

src+=dim;

dst++;

*dst=*src；

src+=dim;

dst++;

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim；

dst++；

*dst=*src;

src+=dim;

dst++;

*dst=*src;

src+=dim；

dst++;

*dst=*src;

src++;

src-=(dim<<5)-dim;

dst-=31+dim；

)

dst+=dst-base+dim；

dst+=32;

src+=(dim<<5)—dim;

)

}

这个函数是通过循环展开来加速程序的。将循环次数减少32倍，同时解决32个像素点来达

成循环展开，由于这32个像素点的解决可以并行解决，因此减少了关键途径的长度，大大加速了程

序。

smooth函数：

voidsmooth(intdim,pixe1*src,pixe1"dst)

(

inti,j,rij；

intrindex=dim;

dst[0].red=(src[0].red+src[1].red+src[dim].red+src[dim+l].red)»2;

dst[0].blue=(src[0].b1ue+src[1].blue+src[dim].blue+src[dim+l].blu

e)»2;

dst[O].green=(src[0].green+src[l].green+src[dim].green+src[dim+l].g

reen)»2;

dst[dim-l].red=(src[dim-1].red+src[dim-2].red+srred+

src[dim*2—2].red)»2;

dst[dim—l].blue=(src[dim-1].blue+src[dim-2].b1ue+src[dim*2-l].b1

ue+src[dim*2-2].blue)»2；

dst[dim-1].green=(src[dim-1].green+src[dim-2].green+src[di

.green+src[dim*2~2].green)»2;

dst[dim*(dim-l)J.red=(src[dim*(dim-1)].red+src[dim*(dim-l)+1].red+src

Ldim*(dim-2)].red+src[dim*(dim—2)+11.red)>>2；

dst[dim*(dim-1)].blue=(src[dim*(dim-1)].blue+src[dim*(dim—1)+1].b

1ue+src[dim*(dim—2)].blue+src[dim*(dim-2)+1].blue)>>2;

dst[dim*(dim—l)].green=(src[dim*(dim-l)].green+src[dim*(dim—1)

+l].green+srcfdim*(dim-2)].green+src[di(dim-2)+11.green)»2;

dst[dim*dim-l].red=(src[dim*dim-l].red+src[dim*dim—2].red+src[dirn,^

(dim—1)-1],red+src[dim*(dim-1)-2].red)»2;

dst[dim*dim-1J.blue=(src[dim*dim-1].blue+src[dim*dim-2].blue+src[dim*

(dim-1)—1].blue+src[dim*(dim-1)-2].blue)»2;

dst[dim*dim-1],green=(src[dim^dim-11.green+src[dim*dim-2].green+src

[dim*(d].green+src[din)*(dim-1)-2J.green)»2;

for(j=l;j<dim-1;j++){

dst[j].red=(src[j].red+src[j-1].red+src[j+l].red+src[j+d

imJ.red+src|j+1+dim].red+src[j-1+dim].red)/6;

dst[j].green=(srcLj].green+src[j-1].green+src[j4-l].gre

en+srcfj+dim].green+src[j+l+dim].green+srcfj-l+dim].green)/6;

dst[j].blue=(src[j].b1ue+src[j-l].b1ue+src[j+l].blue+src[j+dim].bl

ue+src|j+l+dimj.blue+src|j-l+dim].blue)/6;

)

for(j=dim*(dim-l)+l;j<dim*di{

dst[j].red=(srcLj].red+src[j—l].red+src[j+l].red+src[j

-dim].red+src[j+l-dim].red+src[