c++ - 在运行时添加字段 : suffer either vtable-cost or cache miss at destructor

Question

我想在运行时向(假)类添加非静态字段。

它对于解耦很有用，例如systemA.cpp可以为某个Data添加一个int字段，而systemB.cpp可以添加 B 和 C 到同一个 Data 类。

因为这是一个很长的问题，我将分别讨论我的设计、MCVE、它的缺陷、我的方法和问题。

设计

在我的设计中，内存布局与普通类相同。
这是图表:-

在我的用例中，上面的布局比 int-int-int ... B-B-B ... 更快。​​
(我剖析了。)

为简单起见，我锁定每个字段 64 个字节。
用户必须在使用之前将每个所需的字段及其类型注册到我的库中:-

    Ref<int> refInt=addField<int>();  //e.g. systemA.cpp
    Ref<B> refB=addField<B>();        //e.g. systemB.cpp
    Ref<C> refC=addField<C>();

我的库将计算用户在每个 Data 实例中需要多少个字段(在本例中为 3 个)。

然后，他们可以分配一些Data实例，并访问Data的动态字段。

    std::vector<Data> datas=allocate(10);
    refInt.get(datas[0])=8;

要删除数据，用户不必调用任何析构函数(B 或C's) 手动。
^ 这是目标之一。

代码 ( MCVE )

这是我的代码(库级，简化):-

#include <iostream>
#include <vector>
//---- library -----
void* utilAddAddress(void* current,int offset){
    return reinterpret_cast<char*>(current)+offset;
}
int sizePerInstance=0;//accumulate
struct Data{
    void* mem=nullptr;
    Data(void* pmem){mem=pmem;}
};
template<class T>struct Ref{
    int offset=0;
    T& get(Data data){
         return *static_cast<T*>(utilAddAddress(data.mem,offset));
    }
};
template<class T>Ref<T> addField(){
    Ref<T> reff;
    reff.offset=sizePerInstance;
    sizePerInstance+=64;
    return reff;
}
std::vector<Data> allocate(int numInstance){
    void* oNew= ::operator new(static_cast<size_t>( numInstance*sizePerInstance));  
    std::vector<Data> toReturn;
    for(int n=0;n<numInstance;n++){
        toReturn.push_back(Data(utilAddAddress(oNew,n*sizePerInstance)));
    }
    return toReturn;
}

这是它的使用方法:-

class B{    };
class C{   
    std::string danger;    
};
int main(){
    Ref<int> refInt=addField<int>(); //offset = 0
    Ref<B> refB=addField<B>();       //offset = 64
    Ref<C> refC=addField<C>();       //offset = 128
    std::vector<Data> datas=allocate(10);
    refInt.get(datas[0])=8;
    //destructor ?????
}

问题

它有效，但我找不到有效销毁大量 Data 实例的方法。

要销毁 Data 实例，我必须调用每个字段的析构函数:int、B 和 C .
有可能有些字段(例如 C)不是 POD 类型，所以我不能跳过这个阶段。

到目前为止，我只找到了 2 个选择。 (我会假设每个实例的每个字段都被构造):-

1. 按以下顺序调用析构函数:[0]int [0]B [0]C [1]int [1]B [1]C ...
2. 按以下顺序调用析构函数:[0]int [1]int [2]int ... [0]B [1]B ... [0]C [1]C ...

第一选择

这是一种可能的方式(草案):-

std::vector<std::function<......>> deleters;
template<class T>Ref<T> addField(){
    ......
    deleters.push_back([](......){
        static_cast<T*>(......)->~T();
    });
    ......
}

为了适本地调用所有析构函数，我将:-

for(int n=0;n<10;n++){
    for(int m=0;m<3;m++){
        deleters[m](data[n]);
    }
}

我将承受 v-table 成本。 (我剖析)

第二选择

我将遭受缓存未命中，如下图所示。 (我剖析)

问题

当删除大量连续的Data时，如何高效调用所有合适的析构函数？

我不期待完整的代码。粗略的描述/片段就足够了。

旁注:

• 在实际情况下，它通常分配约 4000 个实例。 Data 最多有 30 个字段。
• 该库位于游戏引擎核心中。它支持多种类型，例如数据1 数据2 ...
• 作为一项临时措施，我放弃了对非 POD 字段的支持。

Answer 1

最快的方法是通过利用自定义分配器来实现 O(1)。

所有进入数据的东西都必须使用特定的分配器，std::string是 typedef的 std::basic_string<char> ，它也有一个默认分配器。

using CBString = std::basic_string<char, std::char_traits<char>, CBAllocator<char>>;

现在 Data被销毁，就制作CBAllocator删除其所有池。

您还可以根据 std::is_trivially_destructible 将字段分成两组.要么制作 2 个不同的数据，要么制作一个全无 std::is_trivially_destructible相邻以提高缓存局部性。您现在可以忽略 std::is_trivially_destructible 的析构函数.