7

背景

这适用于游戏引擎中的内存管理器。我已经freelist实现了，如果有这些，我希望有一个编译时列表。（例如 MPL 或 Fusion 向量）。'freelist对应于分配大小，当分配/释放大小小于常量的对象时，它们将转到相应的freelist.

最后，这意味着全局的小对象具有摊销的恒定时间分配和恒定时间释放。（耶。）

问题

问题是生成我需要的类型，所以我最终可能会使用 Fusion 来实例化这些类型。使用的类型有（缩短等）：

template <size_t N>
struct data_block
{
    size_t mSize; // = N
    char mData[N];
};

template <typename T, size_t ElementsPerPage,
    template <typename> class Allocator = std::allocator >
class freelist { /* ... */ };

template <typename T>
class callocator; // allocator that uses malloc/free

's将freelist管理data_block's 的 2 次幂大小，从最小值开始到最大值。所以我想要的是：

static const size_t MinimumSmallSize = 4; // anything smaller gets rounded up
static const size_t MaximumSmallSize = 512; // anything bigger goes to the large allocator
static const size_t ElementsPerPage = 4096;

// mpl magic

要生成这个：

typedef boost::mpl::vector<
    freelist<data_block<4>, ElementsPerPage, callocator>,
    freelist<data_block<8>, ElementsPerPage, callocator>
    // ...
    freelist<data_block<256>, ElementsPerPage, callocator>
    freelist<data_block<512>, ElementsPerPage, callocator>
    > free_list_collection;

显然，我可以手动完成，但我宁愿避免这样做，以获得更通用和可调整的界面。在代码中使用 Fusion 向量也应该比硬编码成员更简单。

问题

我不确定解决这个问题的最佳方法；我以前从未广泛使用过 MPL。有任何想法吗？我有一些糟糕的想法，比如制定一个范围，然后remove_if它不是 2 的幂等，但肯定不是最好的。也许是递归的，每次加倍，推入我的结果向量？我不知道该怎么做。

4

1 回答 1

4

这是我想出的最佳解决方案，而且相当简单。它需要一个元模板log，pow我已经为那些想要玩或尝试它的人提供了它：

#include <boost/mpl/for_each.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/vector.hpp>
#include <iostream>

namespace bmpl = boost::mpl;

//// helpers
template <size_t N, size_t Base>
struct log
{
    static const size_t value = 1 + log<N / Base, Base>::value;
};

template <size_t Base>
struct log<1, Base>
{
    static const size_t value = 0;
};

template <size_t Base>
struct log<0, Base>
{
    static const size_t value = 0;
};

template <size_t N, size_t Power>
struct pow
{
    static const size_t value = N * pow<N, Power - 1>::value;
};

template <size_t N>
struct pow<N, 0>
{
    static const size_t value = 1;
};

//// types and constants
template <size_t N>
struct data_block
{
    size_t mSize; // = N
    char mData[N];
};

template <typename T, size_t ElementsPerPage,
    template <typename> class Allocator = std::allocator >
class freelist { /* ... */ };

template <typename T>
class callocator; // allocator that uses malloc/free

static const size_t MinimumSmallSize = 4;
static const size_t MaximumSmallSize = 512;
static const size_t ElementsPerPage = 4096;

//// type generation
// turn a power into a freelist
template <typename T>
struct make_freelist
{
    static const size_t DataSize = pow<2, T::value>::value;
    typedef data_block<DataSize> data_type;

    typedef freelist<data_type, ElementsPerPage, callocator> type;
};

// list of powers
typedef bmpl::range_c<size_t, log<MinimumSmallSize, 2>::value,
                        log<MaximumSmallSize, 2>::value + 1> size_range_powers;

// transform that list into freelists, into a vector
typedef bmpl::transform<size_range_powers, make_freelist<bmpl::_1>,
                            bmpl::back_inserter<bmpl::vector<> > >::type size_range;

//// testing
struct print_type
{
    template <typename T>
    void operator()(const T&) const
    {
        std::cout << typeid(T).name() << "\n";
    }
};

int main(void)
{
    bmpl::for_each<size_range>(print_type());
    std::cout << std::endl;
}

它的核心只是 astruct和 two typedef。该log技巧大大减小了范围的大小，pow当然只是撤消了log. 完全按照我的意愿工作，我看不出有什么方法可以让它变得更简单。

也就是说，我决定使用 Boost.Pool，所以我不需要我的解决方案（因为它们的池大小是动态的，而不是编译时的。）但这很有趣。

于 2010-01-14T20:26:44.393 回答