代码优化，C代码不响应缓存阻塞

我在一个类中从事一个项目，该类让我们优化C代码。然而，我们运行代码的服务器似乎对常用的优化技术或至少是我们所学的优化技术反应不好。赋值建议使用代码运动、循环展开和阻塞。 以下是一些结构定义：

#ifndef _DEFS_H_
#define _DEFS_H_

#include <stdlib.h>

#define RIDX(i,j,n) ((i)*(n)+(j))

typedef struct {
  char *team;
  char *name1, *email1;
  char *name2, *email2;
} team_t;

extern team_t team;

typedef struct {
   unsigned short red;
   unsigned short green;
   unsigned short blue;
} pixel;

typedef void (*lab_test_func) (int, pixel*, pixel*);

void smooth(int, pixel *, pixel *);
void rotate(int, pixel *, pixel *);

void register_rotate_functions(void);
void register_smooth_functions(void);
void add_smooth_function(lab_test_func, char*);
void add_rotate_function(lab_test_func, char*);

#endif /* _DEFS_H_ */

\ifndef\u DEFS\H_
#定义定义_
#包括
#定义RIDX（i，j，n）（（i）*（n）+（j））
类型定义结构{
char*团队；
字符*name1，*email1；
字符*name2，*email2；
}小组;；
外部小组；
类型定义结构{
无符号短红色；
无符号短绿色；
无符号短蓝色；
}像素；
typedef void（*lab_test_func）（整数，像素*，像素*）；
空洞平滑（整型，像素*，像素*）；
空旋转（整数，像素*，像素*）；
无效寄存器旋转函数（void）；
无效寄存器\平滑\函数（void）；
void add_smooth_函数（lab_test_func，char*）；
void add_rotate_函数（lab_test_func，char*）；
#endif/*_DEFS_H_*/

这是我目前正在使用的函数，它将图像旋转90度：

char naive_rotate_descr[] = "naive_rotate: Naive baseline implementation";
void naive_rotate(int dim, pixel *src, pixel *dst) 
{
    int i, j;

    for (i = 0; i < dim; i++)
    for (j = 0; j < dim; j++)
        dst[RIDX(dim-1-j, i, dim)] = src[RIDX(i, j, dim)];
}

char naive_rotate_descr[]=“naive_rotate:naive基线实现”；
void naive_旋转（int dim，pixel*src，pixel*dst）
{
int i，j；
对于（i=0；i

这是执行效率低下的基线

char rotate_descr[] = "rotate: Current working version";
void rotate(int dim, pixel *src, pixel *dst) 
{
    int i, j;
    int ii, jj;
    int dim_min_one = dim - 1;

    for (i = 0; i < dim; i+=8){
        for (j = 0; j < dim; j+=8){
            for(ii = 0; ii < 8; ii++){
                for(jj = 0; jj < 8; jj+=8){
                    dst[RIDX(dim_min_one-(jj+j), (i+ii), dim)] = src[RIDX((i+ii), (j+jj), dim)];
                    dst[RIDX(dim_min_one-(jj+j+1), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+1), dim)];
                    dst[RIDX(dim_min_one-(jj+j+2), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+2), dim)];
                    dst[RIDX(dim_min_one-(jj+j+3), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+3), dim)];
                    dst[RIDX(dim_min_one-(jj+j+4), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+4), dim)];
                    dst[RIDX(dim_min_one-(jj+j+5), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+5), dim)];
                    dst[RIDX(dim_min_one-(jj+j+6), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+6), dim)];
                    dst[RIDX(dim_min_one-(jj+j+7), (i+ii), dim)] = src[RIDX((i+ii), (j+jj+7), dim)];

                }
            }
        }
    }
}

char rotate\u descr[]=“旋转：当前工作版本”；
无效旋转（整型变暗，像素*src，像素*dst）
{
int i，j；
int ii，jj；
int dim_min_one=dim-1；
对于（i=0；i

这是阻挡和展开的组合

char rotate1_descr[] = "rotate1: Simple 16 blocking";
void rotate1(int dim, pixel *src, pixel *dst) 
{
    int i, j;
    int ii, jj;
    int dim_min_one = dim - 1;

    for (i = 0; i < dim; i+=16){
        for (j = 0; j < dim; j+=16){
            for(ii = 0; ii < 16; ii++){
                for(jj = 0; jj < 16; jj++){
                    dst[RIDX(dim_min_one-(jj+j), (i+ii), dim)] = src[RIDX((i+ii), (j+jj), dim)];
                }
            }
        }
    }
}

char rotate1_descr[]=“rotate1:Simple 16 blocking”；
无效旋转1（整数尺寸、像素*src、像素*dst）
{
int i，j；
int ii，jj；
int dim_min_one=dim-1；
对于（i=0；i

这只是简单的阻塞。 现在，正在测试代码的服务器中有24个Intel（R）Xeon（R）X5660@2.80GHz CPU。测试代码对阻塞和展开循环的速度提高了1.2，对简单阻塞的速度提高了1.4

在我自己的计算机上，它是核心i7 2.7GHz，而另一台学校服务器是24 Intel®Xeon®处理器E5-2420，频率为1.9GHz，阻塞、展开和仅阻塞的速度都是1.9

同样，在所有系统上，8比16的块大小在性能上似乎没有差异，但是，32会对性能造成影响

---

现在，另一款ES-2420的缓存容量为15mb，而X5660的缓存容量为12mb，但我觉得这不足以让阻塞的效果相形见绌，也不足以让展开降低性能。我在网上找不到任何关于X5660优化的内容，也找不到响应良好的技术。所以我的问题是，处理器之间的什么差异会导致对缓存阻塞的响应出现如此大的差异，我可以从这种差异中提取什么来编写在其上运行得更好的代码。教科书和讲座并没有真正给我解决这个问题的工具，因为他们建议的所有技术都不能很好地与我们必须运行它的服务器配合使用。

如果您可以在每台机器上安装，您可以测量缓存未命中率和其他有趣的参数，以确定为什么每个缓存都有不同的加速。

不幸的是，我无法在服务器上安装软件。您遗漏了最重要的信息，即

RIDX

的定义。既然

RIDX

每像素调用两次，那就是开始调查的地方，如果我是正确的，你可以重写算法以完全消除

RIDX

。“dim”的值是多少？“像素”是什么类型？我在定义中添加了，dim将是正方形图片尺寸的int，并且始终是32的倍数。