[CSAPP] Performance Lab 实验笔记

perflab这节的任务是利用书中知识,来对图像处理中的Rotate和Smooth操作函数进行优化。这次没对上电波,觉得学了一堆屠龙之技。于我个人理解,现在计算机配置比以前高多了,连SWAP分区都几近废弃了,对于一般开发者来讲,代码效率瓶颈首先是架构,其次是算法,最后才是书里教的这些小细节。而且这节也没个具体的分数标准,优化了半天也不知道自己写的算啥水平,缺了前面几节那种攻克难题的成就感。不过也有可能是因为我太菜了 XD

前期准备

这次的开发环境被我迁移到了WSL上,系统版本为ubuntu 18.04 LTS, 使用VSCode remote作为主要编辑器,软件包只装了以下几个:

sudo apt-get install build-essential #安装gcc、make等常用开发工具
sudo apt-get install libc6-dev		#安装c++库
sudo apt-get install g++-multilib	#让64位机器可以编译32位程序

知识点

主要是CSAPP第五章和第六章所总结的一些小技巧

  • 消除冗余的函数调用。比如避免在for循环里用strlen。
  • 消除不必要的内存引用。比如引入临时变量来把中间结果保存到寄存器里,在全部计算完成后把最终结果存到数组或全局变量里。
  • 循环展开,降低判断语句和增减循环变量的开销。
  • 累积变量和重新组合,提高指令并行性。
  • 功能性风格重写条件操作,即用三元运算符。
  • 提高空间局部性,尽量按照数组在内存里存储的顺序,以1为步长进行读取。
  • 提高时间局部性,一旦在内存里读出一个变量,就尽可能频繁且集中的使用它。

Rotate

对于Rotate操作,我主要优化了以下几点:

  1. 因为高速缓存读操作不命中的惩罚比写操作高,又因为空间局部性原则,所以优先在dst数组上以1为步长遍历。

  2. 为了消除冗余的运算,我们可以对RIDX宏进行拆解,分析可知

dst[dim*dim-dim + i - dim*j] == src[dim*i + j]
  1. 根据讲义里提示所有图片尺寸为32的倍数,又因为CACHE_BLOCK大小为32,所以我们可对原代码进行32路展开
  2. 同样是根据空间局部性原则,尽量使内部循环步长短于外部循环
void rotate(int dim, pixel *src, pixel *dst)
{
    // dst = dim*dim-dim + i - dim*j
    // src = dim*i + j
    int i,j;
    dst+=(dim*dim-dim);
    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++;      //j++ => src+=1
            dst-=dim;   //j++ => dim+=-dim
        }    
        //i+=32 => src+=32*dim, then neutralize the effects of for(j)
        src+=31*dim;
        //i+=32 => dst+=32, then neutralize the effects of for(j)
        dst+=dim*dim+32;
    }
}

除此之外也尝试过用临时变量代替dim*dim+32,不过收效甚微。以上代码的成绩在16左右

Rotate: Version = naive_rotate: Naive baseline implementation:
Dim             64      128     256     512     1024    Mean
Your CPEs       2.8     4.2     5.3     10.6    11.5
Baseline CPEs   14.7    40.1    46.4    65.9    94.5
Speedup         5.2     9.4     8.8     6.2     8.2     7.4

Rotate: Version = rotate: Current working version:
Dim             64      128     256     512     1024    Mean
Your CPEs       2.7     2.2     2.2     2.7     4.2
Baseline CPEs   14.7    40.1    46.4    65.9    94.5
Speedup         5.4     18.0    21.0    24.8    22.6    16.3

Smooth

对于Smooth操作,我的想法很直白:

  1. avg中有大量的冗余的max和min函数调用,可通过分类讨论四角、四边、中间的边界条件来优化之。
  2. src的每个单元格都被多次读取,利用效率不高,可以通过复用读取的值来减少读取次数。

在以上思想的指导下,我又加了几个辅助函数,最终代码如下:

pixel_sum p_sum[512][512];
static void three_pixel_sum(pixel_sum *sum, pixel a, pixel b, pixel c)
{
    sum->red=(int)(a.red+b.red+c.red);
    sum->green=(int)(a.green+b.green+c.green);
    sum->blue=(int)(a.blue+b.blue+c.blue);
}
static void two_pixel_sum(pixel_sum *sum, pixel a, pixel b){
    sum->red=(int)(a.red+b.red);
    sum->blue=(int)(a.blue+b.blue);
    sum->green=(int)(a.green+b.green);
}
static void add_pixel_sum(pixel_sum *a, pixel_sum b){
    a->red+=b.red;
    a->green+=b.green;
    a->blue+=b.blue;
}
static void sum2pixel(pixel *current_pixel, pixel_sum sum, int num)
{
    current_pixel->red = (unsigned short)(sum.red / num);
    current_pixel->green = (unsigned short)(sum.green / num);
    current_pixel->blue = (unsigned short)(sum.blue / num);
    return;
}
void smooth(int dim, pixel *src, pixel *dst)
{
    pixel_sum sum;
    int r,c;
    int dimsubone=dim-1;
    //初始化
    for(r=0;r<dim;r++){
        for(c=0;c<dim;c++){
            initialize_pixel_sum(&p_sum[r][c]);
        }
    }
    //计算中间部分
    for(r=1;r<dimsubone;r++){
        for(c=1;c<dimsubone;c++){
            three_pixel_sum(&sum,src[RIDX(r,c-1,dim)],src[RIDX(r,c,dim)],src[RIDX(r,c+1,dim)]);
            add_pixel_sum(&p_sum[r-1][c],sum);
            add_pixel_sum(&p_sum[r][c],sum);
            add_pixel_sum(&p_sum[r+1][c],sum);
        }
    }
    //计算上下两边
    for(c=1;c<dimsubone;c++){
        three_pixel_sum(&sum,src[RIDX(0,c-1,dim)],src[RIDX(0,c,dim)],src[RIDX(0,c+1,dim)]);
        add_pixel_sum(&p_sum[0][c],sum);
        add_pixel_sum(&p_sum[1][c],sum);
        three_pixel_sum(&sum,src[RIDX(dimsubone,c-1,dim)],src[RIDX(dimsubone,c,dim)],src[RIDX(dimsubone,c+1,dim)]);
        add_pixel_sum(&p_sum[dim-2][c],sum);
        add_pixel_sum(&p_sum[dimsubone][c],sum);
    }
    //计算左右两边
    for(r=1;r<dimsubone;r++){
        two_pixel_sum(&sum,src[RIDX(r,0,dim)],src[RIDX(r,1,dim)]);
        add_pixel_sum(&p_sum[r-1][0],sum);
        add_pixel_sum(&p_sum[r][0],sum);
        add_pixel_sum(&p_sum[r+1][0],sum);
        two_pixel_sum(&sum,src[RIDX(r,dim-2,dim)],src[RIDX(r,dimsubone,dim)]);
        add_pixel_sum(&p_sum[r-1][dimsubone],sum);
        add_pixel_sum(&p_sum[r][dimsubone],sum);
        add_pixel_sum(&p_sum[r+1][dimsubone],sum);
    }
   //计算四角
  two_pixel_sum(&sum,src[RIDX(0,0,dim)],src[RIDX(0,1,dim)]);
    add_pixel_sum(&p_sum[0][0],sum);
    add_pixel_sum(&p_sum[1][0],sum);
    two_pixel_sum(&sum,src[RIDX(0,dim-2,dim)],src[RIDX(0,dimsubone,dim)]);
    add_pixel_sum(&p_sum[0][dimsubone],sum);
    add_pixel_sum(&p_sum[1][dimsubone],sum);
    two_pixel_sum(&sum,src[RIDX(dimsubone,0,dim)],src[RIDX(dimsubone,1,dim)]);
    add_pixel_sum(&p_sum[dim-2][0],sum);
    add_pixel_sum(&p_sum[dimsubone][0],sum);
    two_pixel_sum(&sum,src[RIDX(dimsubone,dim-2,dim)],src[RIDX(dimsubone,dimsubone,dim)]);
    add_pixel_sum(&p_sum[dim-2][dimsubone],sum);
    add_pixel_sum(&p_sum[dimsubone][dimsubone],sum);
    //中部有9个相邻点
    for(r=1;r<dimsubone;r++){
        for(c=1;c<dimsubone;c++){
            sum2pixel(&dst[RIDX(r,c,dim)],p_sum[r][c],9);
        }
        sum2pixel(&dst[RIDX(r,0,dim)],p_sum[r][0],6);
        sum2pixel(&dst[RIDX(r,dimsubone,dim)],p_sum[r][dimsubone],6);
    }
    //四边有6个相邻点
    for(c=1;c<dimsubone;c++){
        sum2pixel(&dst[RIDX(0,c,dim)],p_sum[0][c],6);
        sum2pixel(&dst[RIDX(dimsubone,c,dim)],p_sum[dimsubone][c],6);
    }
    //四角有4个相邻点
    sum2pixel(&dst[RIDX(0,0,dim)],p_sum[0][0],4);
    sum2pixel(&dst[RIDX(dimsubone,0,dim)],p_sum[dimsubone][0],4);
    sum2pixel(&dst[RIDX(0,dimsubone,dim)],p_sum[0][dimsubone],4);
    sum2pixel(&dst[RIDX(dimsubone,dimsubone,dim)],p_sum[dimsubone][dimsubone],4);

}

分数在23左右

Smooth: Version = naive_smooth: Naive baseline implementation:
Dim             32      64      128     256     512     Mean
Your CPEs       52.5    50.2    50.6    52.0    51.7
Baseline CPEs   695.0   698.0   702.0   717.0   722.0
Speedup         13.2    13.9    13.9    13.8    14.0    13.8

Smooth: Version = smooth: Current working version:
Dim             32      64      128     256     512     Mean
Your CPEs       28.8    29.4    29.6    30.6    32.3
Baseline CPEs   695.0   698.0   702.0   717.0   722.0
Speedup         24.1    23.7    23.8    23.4    22.3    23.5

还可以继续利用动态规划思想进行优化,但我懒得搞了。像这种分类情况多,代码量大的题目我确实是不怎么喜欢做。

©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值