8

で単純なメモリ プール アロケータを使用しようとしていますstd::unordered_map。std::string私はこの同じアロケータを と の両方で一見成功したように使用しましたstd::vector。unordered_map (およびベクター) に含まれるアイテムでもこのアロケーターを使用するようにしたいので、アロケーターを でラップしましたstd::scoped_allocator_adaptor。

簡略化された定義セット:

template <typename T>
using mm_alloc = std::scoped_allocator_adaptor<lake_alloc<T>>;

using mm_string = std::basic_string<char, std::char_traits<char>, mm_alloc<char>>;
using mm_vector = std::vector<mm_string, mm_alloc<mm_string>>;
using mm_map = std::unordered_map<mm_string, mm_vector, std::hash<mm_string>, std::equal_to<mm_string>, mm_alloc<std::pair<mm_string, mm_vector>>>;

次のように初期化されます。

lake pool;
mm_map map { mm_alloc<std::pair<mm_string, mm_vector>>{pool} };

lake_allocイテレータコードの残りの部分を以下に示します。私が Clang 3.3 で得ているエラーは、allocator_type(この場合はベクトル化する文字列のペアの mm_alloc) を独自のにできないということ__pointer_allocatorです。これは、ハッシュ マップの実装に使用される内部型です。以下の部分的なエラー出力:

lib/c++/v1/__hash_table:848:53: error: no matching conversion for functional-style
      cast from 'const allocator_type' (aka 'const std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::pair<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::vector<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, krystal::lake> > > >, krystal::lake> >') to '__pointer_allocator' (aka
      'std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::__hash_node<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, krystal::lake> > > >, void *> *, krystal::lake> >')
    : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
                                                    ^~~~~~~~~~~~~~~~~~~~~~~

GCC 4.7.1 では、ハッシュ マップの内部構造で同様のエラーが発生するため、明らかに間違っていますが、これは STL のアロケーターへの最初の進出であり、途方に暮れています。

カスタム アロケータは次のとおりです。いくつかの穴がある単純な実装ですが、このバージョンは、ベクトルと文字列に数メガのデータが含まれるテスト ケースでうまく機能します。

#include <cstddef>
#include <memory>
#include <scoped_allocator>

class lake {
    const size_t block_size_;
    mutable std::vector<std::unique_ptr<uint8_t[]>> blocks_;
    mutable uint8_t *arena_, *pos_;

    static constexpr const size_t DefaultBlockSize = 48 * 1024;

    void add_block(size_t of_size) const {
        blocks_.emplace_back(new uint8_t[of_size]);
        pos_ = arena_ = blocks_.back().get();
    }

    inline void add_block() const { add_block(block_size_); }

public:
    lake(const size_t block_size)
    : block_size_ {block_size}
    {
        add_block();
    }
    lake() : lake(DefaultBlockSize) {}

    void* allocate(size_t n) const {
        if (pos_ + n - arena_ > block_size_) {
            if (n > block_size_)
                add_block(n); // single-use large block
            else
                add_block();
        }

        auto result = pos_;
        pos_ += n;
        return result;
    }

    void deallocate(void* p, size_t n) const {
    }
};


template <typename T, typename Alloc>
class krystal_alloc {
    const Alloc* allocator_;

public:
    using value_type = T;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;

    template <typename U>
    struct rebind { typedef krystal_alloc<U, Alloc> other; };

    krystal_alloc() : allocator_{ new Alloc() } {} // not used
    krystal_alloc(const Alloc& alloc) : allocator_{ &alloc } {}

    pointer address(reference v) {
        return 0;
    }

    const_pointer address(const_reference v) {
        return 0;
    }

    size_type max_size() const {
        return static_cast<size_type>(-1) / sizeof(value_type);
    }

    pointer allocate(size_type n) {
        return static_cast<pointer>(allocator_->allocate(sizeof(T) * n));
    }

    void deallocate(pointer p, size_type n) {
        allocator_->deallocate(p, n);
    }
};

template <typename T, typename Alloc, typename U>
inline bool operator==(const krystal_alloc<T, Alloc>&, const krystal_alloc<U, Alloc>) { return true; }

template <typename T, typename Alloc, typename U>
inline bool operator!=(const krystal_alloc<T, Alloc>&, const krystal_alloc<U, Alloc>) { return false; }


// -- standard usage
template <typename T>
using lake_alloc = krystal_alloc<T, lake>;
4

1 に答える 1

8

基本的なエラーは、krystal_alloc に「変換コンストラクター」がないことだと思います。

template <class U>
    krystal_alloc(const krystal_alloc<U, Alloc>& u)
        : allocator_(u.allocator_) {}

正しく実装したかどうかはわかりませんが、それは私の最善の推測です。これを機能させるには、friend ステートメントが必要です。

template <class U, class A> friend class krystal_alloc;

また、unordered_map のアロケーターの key_type に「const」を追加することをお勧めします。

using mm_map = std::unordered_map<mm_string, mm_vector, std::hash<mm_string>,
                              std::equal_to<mm_string>,
                              mm_alloc<std::pair<const mm_string, mm_vector>>>;

内容器の代わりに使ってもいいと思います。あなたの例は、両方の方法でコンパイルされます。実行時の動作についてはテストしませんでした。lake_allocmm_alloc

于 2013-07-12T18:39:28.907 に答える