如何实现可变大小的缓存对象以减少 C++ 中的内存分配？

Question

在表演之前，人们让我大吃一惊：是的，在问这个问题之前我已经完成了分析:)

我再次查看我的 一个类型容器，虽然我有一个可行的解决方案，但性能很差，因为每种类型缓存的项目会导致在堆上进行单独分配（这当然很昂贵）。

基于对程序输入的静态分析，我找到了一种方法来了解可能放入正在传递的缓存对象中的所有对象所需的总大小。基本上，我有一个可以在给定缓存对象中构造的对象列表，因此我可以提前知道我可能需要缓存的对象的大小，但不是在编译时——仅在运行时。

基本上，我想做的就是 boost::make_shared 所做的——获取单个内存块，并构造 shared_ptr 位以及受控对象同一个内存块。

我不必担心保留复制行为，因为缓存对象是不可复制的，并且由客户端通过指针传递（它通常存储在 ptr_vector 或 std::auto_ptr< /代码>）。

然而，我不熟悉如何实现这样一个容器，即如何遵循对齐限制等。

在伪代码中，我想做的是：

//I know a lot of what's in here is not portable -- I need to run only on x86
//and x64 machines. Yes, this couple of classes looks hacky, but I'd rather
//have one hacky class than a whole programfull :)

class CacheRegistrar
{
    //Blah blah
public:
    //Figures out what objects will be in the cache, etc
    const std::vector<std::size_t>& GetRequiredObjectSizes() const;
    //Other stuff...
    template <typename T>
    void RegisterCacheObject();
    template <typename T>
    std::size_t GetObjectIndex() const;
    // etc.
};

class CacheObject;

std::auto_ptr<CacheObject> CacheObjectFactory(const CacheRegistrar& registrar)
{
    //Pretend this is in a CPP file and therefore CacheObject is defined...
    const std::vector<size_t>& sizes(registrar.GetRequiredObjectSizes());
    std::size_t sumOfCache = std::accumulate(sizes.begin(), sizes.end());
    sumOfCache += sizeof(CacheObject);
    boost::scoped_array<char> buffer(new char[] sumOfCache);
    CacheObject *obj = new (reinterpret_cast<void *>(buffer.get())) CacheObject;
    buffer.release(); //PSEUDOCODE (boost::scoped_array has no release member);
    return std::auto_ptr<CacheObject>(obj); //Nothrow
}

class CacheObject
{
    CacheRegistrar *registrar; //Set by my constructor
public:
    template<typename T>
    T& Get()
    {
        char * startOfCache = reinterpret_cast<char *>(this) + 
            sizeof(CacheObject);
        char * cacheItem = startOfCache + registrar->GetObjectIndex<T>();
        return *reinterpret_cast<T*>(cacheItem);
    }
};

我的一般概念在这里合理吗？有更好的方法来实现这一点吗？

Answer 1

但首先，请阅读Andrei Alexandrescu 的这篇文章，了解他认为自己应该写的内容在那一章中——一种使用堆层构建堆的方法（真正由你自己构建）。我使用堆层来构建Hoard，DieHard 和 DieHarder ，以及我们的 OOPLSA 2002 论文中使用的自定义分配器，重新考虑自定义内存分配，在开始创建自定义分配器之前您还应该阅读该内容。

Answer 2

查看 Loki 小对象分配器。

快速谷歌搜索没有产生任何直接的以人为本的文档。有 DOxygen 生成的文档，但不是特别好理解。然而，设计和实现记录在 Andrei Alexandrescu 的“Modern C++ Design”中。

如果您只想有效回收给定类的对象，请考虑一个简单的空闲列表 - 可能是原始存储块的空闲列表。

干杯&呵呵，

Answer 3

我看到的关键问题是

返回auto_ptr

为以非默认方式分配的内存 。您可以通过定义合适的重载删除来解决此问题，但最好将自己的销毁函数定义为工厂的一部分。如果这样做，您还可以将内存管理本地化到 Cache 类中，从而使您可以更自由地提高该类的本地性能。
当然，使用智能指针来控制内存管理是一个好主意；您需要做的是定义自己的分配器并定义一个 smart_ptr 来使用它。

作为参考，管理自定义分配的另一种方法是定义自定义 new 运算符。即这种事情：

struct Cache
{
    void* allocate(size_t size)
    {
        size_t blockSize = sizeof(size_t) + size;
        // Placeholder: do what ever appropriate to blocks of size 'blockSize'
        return malloc(blockSize);
    }
    void destroy(void* p)
    {
        size_t* block = reinterpret_cast<size_t*>(p);
        size_t blockSize = *block;
        // Placeholder: do what ever appropriate to blocks of size 'blockSize'
        free(p);
    }

};
Cache cache;


void* operator new (size_t size, Cache& cache )
{
    return cache.allocate(size);
}

struct CacheObject 
{
    void operator delete(void* p)
    {
        cache.destroy(p);
    }
};


CacheObject* co = new (cache) CacheObject;