c++ - C++ 中缓存对齐内存使用的类模板

Question

(提供你理解我的问题需要的信息很多，不过已经压缩了)

我尝试实现一个类模板来分配和访问对齐的数据缓存。这非常有效，但是尝试实现对数组的支持是一个问题。

从语义上讲，代码应在内存中为单个元素提供此映射，如下所示:

cache_aligned<element_type>* my_el = 
          new(cache_line_size) cache_aligned<element_type>();
| element | buffer |

访问(到目前为止)如下所示:

*my_el; // returns cache_aligned<element_type>
**my_el; //returns element_type
*my_el->member_of_element();

但是对于一个数组，我想要这个:

 cache_aligned<element_type>* my_el_array = 
         new(cache_line_size)  cache_aligned<element_type()[N];
 | element 0 | buffer | element 1 | buffer | ... | element (N-1) | buffer |

到目前为止我有以下代码

template <typename T>
class cache_aligned {
    private:
        T instance;
    public:
        cache_aligned()
        {}
        cache_aligned(const T& other)
        :instance(other.instance)
        {}
        static void* operator new (size_t size, uint c_line_size) {
             return c_a_malloc(size, c_line_size);
        }
        static void* operator new[] (size_t size, uint c_line_size) {
             int num_el = (size - sizeof(cache_aligned<T>*) 
                              / sizeof(cache_aligned<T>);
             return c_a_array(sizeof(cache_aligned<T>), num_el, c_line_size);
        }
        static void operator delete (void* ptr) {
             free_c_a(ptr);
        }
        T* operator-> () {
             return &instance;
        }
        T& operator * () {
             return instance;
        }
};

函数cache_aligned_malloc

void* c_a_array(uint size, ulong num_el, uint c_line_size) {
    void* mem = malloc((size + c_line_size) * num_el + sizeof(void*));
    void** ptr = (void**)((long)mem + sizeof(void*));
    ptr[-1] = mem;
    return ptr;
}

void free_c_a(void ptr) {
    free(((void**)ptr)[-1]);
}

问题就在这里，访问数据应该是这样的:

my_el_array[i]; // returns cache_aligned<element_type>
*(my_el_array[i]); // returns element_type
my_el_array[i]->member_of_element();

我的解决方案是:

(1) 与此类似，重载 sizeof 运算符:

static size_t operator sizeof () {
   return sizeof(cache_aligned<T>) + c_line_size;
}

--> 不可能，因为重载 sizeof 运算符是非法的

(2) 像这样，为指针类型重载运算符 []:

static T& operator [] (uint index, cache_aligned<T>* ptr) {
    return ptr + ((sizeof(cache_aligned<T>) + c_line_size) * index);
}

--> 无论如何在 C++ 中是不可能的

(3) 完全微不足道的解决方案

template <typename T> cache_aligned {
    private:
          T instance;
          bool buffer[CACHE_LINE_SIZE]; 
          // CACHE_LINE_SIZE defined as macro
    public:
          // trivial operators and methods ;)
};

--> 我不知道这是否可靠，实际上我在 linux 中使用 gcc-4.5.1 ...

(4) 替换T实例；通过 T* instance_ptr；在类模板中并使用运算符 [] 来计算元素的位置，如下所示:

|指向实例的指针 | ----> |元素 0 |缓冲区 | ... |元素 (N-1) |缓冲区 |

这不是预期的语义，因为类模板的实例在计算元素地址时成为瓶颈。

感谢阅读!我不知道如何缩短问题。如果您能提供帮助，那就太好了!任何解决方法都会有很大帮助。

我知道对齐是 C++0x 中的扩展。但是，在 gcc 中它还不可用。

你好，你好

Answer 1

当 c_line_size 是编译时整数常量时，当然最好根据 sizeof T 用 char 数组填充 cache_aligned。

您还可以检查 2 个 T-s 是否适合一个缓存行并相应地降低对齐要求。

不要期望这样的优化会产生奇迹。我认为某些算法的性能提高 2 倍是您可以避免缓存行拆分的上限。