c代码优化的光滑功能

Question

我试图优化一个平滑的函数，给定图像平滑/模糊边缘，用图像中的每个像素代替周围像素的平均值（图像的维度是矩阵）。优化的代码如下：

int i, j, ii, jj; 
pixel_sum ps; 

for (j = 0; j < dim; j++){ 
    for (i = 0; i < dim; i++){ 
     initialize_pixel_sum(&ps); 
     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(&ps, src[RIDX(ii,jj,dim)]); 
      } 
     } 
     dst[RIDX(i,j,dim)].red = ps.red/ps.num; 
     dst[RIDX(i,j,dim)].green = ps.green/ps.num; 
     dst[RIDX(i,j,dim)].blue = ps.blue/ps.num; 
    } 
} 

我发现了一个优化的版本，这看起来像下面：

int i, j, myJ; 

//cornors 
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; 

//sides 
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; 
} 

有人能解释这是如何优化工作？

Answer 1

由于您没有显示很多东西的定义（accumulate_sum，pixel_sum,RIDX等），因此很难确定。看起来代码的第一个版本按行和列迭代数据，第二个版本首先处理角点，然后处理边缘，然后处理其余数据。您正在处理基于其周围像素的像素。角点和边缘的相邻像素较少，因此处理它们更容易一些。打破这些特殊情况可以使其代码简化。第二个版本然后是unrolls最里面的两个循环，同时处理其余的数据，这是唯一可能的，因为你已经消除了所有的特殊情况（边缘和角落）。

这个改变是否实际上是一个“优化”，是读者留下的练习。你需要在两个版本上运行性能测试来确定。即使第二个版本效率更高，第一个版本的可读性也要高得多。