Question

我正在尝试确定处理器的关联性。我有Intel Core i5-2500：

L1数据：32 Kb，8路组关联

L1指令：32 Kb，8路组关联

L2：256 Kb，8路组关联

L3：6 Mb，12路集关联，在所有内核之间共享

我以处理器滴答度数衡量对数组元素的平均访问时间。数组分为多个片段。

在循环中，我增加了片段的数量。两个相邻片段之间的距离等于L3缓存大小。我访问所有片段的第一个元素，然后访问第二个元素，依此类推。每个元素都包含下一个元素的索引。最后一个元素包含第一个元素的索引。

它看起来像这样：enter image description here

当碎片数大于缓存的关联性时，平均访问时间应增加。

我得到以下结果： enter image description here

第一个跳转对应于TLB的关联性，第二个跳转对应于L1和L2缓存的关联性，但是我不明白为什么超过L3缓存的关联性后时间没有增加。

我还尝试了不同的尺寸和偏移量

我做错什么了吗？还是我在代码中有一些错误？

能给我解释一下吗？这是代码：

#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

#define SIZE 6291456  //6 Mb
#define OFFSET 6291456
#define ROUNDS 200
#define MIN_FRAGMENTS_COUNT 1
#define MAX_FRAGMENTS_COUNT 32

void FreeArray(int* array, int size) {
  assert(size > 0 && "Size must be gerater than zero\n");

  if (NULL == array) {
    return;
  }

  for (int i = 0; i < size; ++i) {
    array[i] = 0;
  }
  free(array);
}

int* CreateArray(int size) {
  assert(size > 0 && "Size must be greater than zero\n");

  return calloc(size, sizeof(int));
}

unsigned long long int GetTicksCount(void) {
  unsigned int high = 0;
  unsigned int low = 0;

  __asm__ __volatile__("rdtsc" : "=a"(low), "=d"(high));
  return (((unsigned long long int)high) << 32 | (unsigned long long int)low);
}

void SetIndexes(int* array, int fragment_size, int offset,
                int fragments_count) {
  assert(NULL != array && "Pointer to array must not be NULL\n");
  assert(fragment_size > 0 && "Fragmnet size must be greater than zero\n");
  assert(offset > 0 && "Offset must be greater than zero\n");
  assert(fragments_count > 0 && "Fragments count must be greater than zero\n");
  assert(fragment_size <= offset &&
         "Fragment size must not be greater than offset\n");

  int last_fragment = fragments_count - 1;
  int last_element = fragment_size - 1;

  for (int i = 0; i < last_element; ++i) {
    for (int j = 0; j < last_fragment; ++j) {
      array[j * offset + i] = (j + 1) * offset + i;  //Go in the same element of next fragment
    }
    array[last_fragment * offset + i] = i + 1;  // Go in the next element from last fragment
  }
  array[last_fragment * offset + last_element] = 0; // Go in first element from last element
}

unsigned long long int CalcAccessTime(int* array, int size) {
  assert(NULL != array && "Pointer to array must not be NULL\n");
  assert(size > 0 && "Size must be greater than zero\n");          

  unsigned long long int start = 0;
  unsigned long long int end = 0;
  unsigned long long int min_time = ULLONG_MAX;
  int index = 0;  

  for (int i = 0; i < ROUNDS; ++i) {
    start = GetTicksCount();
    for (int j = 0; j < size; ++j) {
      index = array[index];
    }
    end = GetTicksCount();

    unsigned long long int cur_time = (end - start) / size;

    if (cur_time < min_time) {
      min_time = cur_time;
    }
  }
  return min_time;
}

int main(int argc, char** argv) {
  int integers_count = SIZE / sizeof(int);
  int offset_int = OFFSET / sizeof(int);

  for (int i = MIN_FRAGMENTS_COUNT; i <= MAX_FRAGMENTS_COUNT; ++i) {
    int size = i * offset_int;
    int* array = CreateArray(size);

    if (NULL == array) {
      return -1;
    }

    SetIndexes(array, integers_count / i, offset_int, i);

    printf("Fragments: %d\n", i);
    printf("Time: %llu\n", CalcAccessTime(array, integers_count));

    FreeArray(array, size);
  }
  return 0;
}

Answer 1

与核心缓存不同，LLC具有更高级别的集合映射。

您通常不希望将整个内存区域映射到同一LLC切片中的相邻集中，因为那样的话，距离该切片较远的内核的访问时间将非常糟糕。相反，在常见情况下，您希望数据尽可能均匀地分布。为此，他们在确定切片的映射中添加了哈希函数。

例外是用例，您需要使用所谓的“ sub-NUMA群集”或“核心群集”，在这种情况下，您可以通过显式配置覆盖该分布。

散列应该在更高的位上工作，以更好地分散存储区域，因此跳过LLC大小将不起作用。您仍然在 multiple 切片中的同一集合上着陆，这意味着您可以有效地获得关联性乘以切片数。但是，根据您的结构对齐方式，不一定会获得最佳分布，因此您可能会开始看到跃迁超出该关联性级别。

这是一篇有关切片哈希的更多详细信息的论文：https://arxiv.org/pdf/1508.03767.pdf

确定Cpu缓存关联性

1 个答案: