【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

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