c++ - 在 map 上调用保护区时出现访问冲突

Question

我有一些与自定义分配器一起使用的unordered_maps。在本例中，我使用一个基本的凹凸分配器，它只是简单地从现有的连续 block 中线性分配新内存。

但是，当我尝试在一段时间后在这些 map 上调用保留时，它们会在 std 列表文件中的行抛出访问违规异常，我将在下面显示:

    _List_unchecked_const_iterator& operator++() noexcept {
        _Ptr = _Ptr->_Next;
        return *this;
    }

我的分配器还剩足够的内存，所以我不认为这是因为我内存不足。

这是一些演示它的自包含代码。复制/粘贴并运行它以查看问题。

#include <stdlib.h> 
#include <unordered_map>
#include <vector>
#include <list>
#include <memory>

#define SEQ(type, val) sizeof(type) * val

struct ImpAllocator {
    virtual void* Allocate(size_t pSize) = 0;
    virtual void Free(void* pPtr) = 0;
};

struct SysAllocator : public ImpAllocator {
    void* Allocate(size_t pSize) override {
        return malloc(pSize);
    }

    void Free(void* pPtr) override {
        free(pPtr);
    }

};

template <class T>
class StdAllocatorWrapper {
public:
    std::shared_ptr<ImpAllocator> mInternalAllocator;

    using value_type = T;

    StdAllocatorWrapper() = default;
    StdAllocatorWrapper(std::shared_ptr<ImpAllocator> pInternalAllocator) :
        mInternalAllocator(pInternalAllocator)
    {}
    ~StdAllocatorWrapper() = default;
    StdAllocatorWrapper(const StdAllocatorWrapper<T>& pOther) = default;

    template<class U>
    StdAllocatorWrapper(const StdAllocatorWrapper<U>& pOther) {
        this->mInternalAllocator = pOther.mInternalAllocator;
    }

    value_type* allocate(size_t pNumberOfObjects) {
        return reinterpret_cast<T*>(mInternalAllocator->Allocate(SEQ(T, pNumberOfObjects)));
    }

    void deallocate(value_type* pPointer, size_t pNumberOfObjects) {
        mInternalAllocator->Free(pPointer);
    }
};

template <class T, class U>
bool operator==(StdAllocatorWrapper<T> const& pL, StdAllocatorWrapper<U> const& pR) noexcept {
    return pL.mInternalAllocator == pR.mInternalAllocator;
}

template <class T, class U>
bool operator!=(StdAllocatorWrapper<T> const& pL, StdAllocatorWrapper<U> const& pR) noexcept {
    return !(pL == pR);
}

template<typename T> using AllocWrapper = StdAllocatorWrapper<T>;
template<typename T, typename K> using Pair = std::pair<const T, K>;
template<typename T, typename K> using PairAllocWrapper = StdAllocatorWrapper<Pair<T, K>>;
template<typename T> using AllocatedVector = std::vector<T, AllocWrapper<T>>;
template<typename T> using AllocatedList = std::list<T, AllocWrapper<T>>;
template<typename T, typename K> using AllocatedUnorderedMap = std::unordered_map<T, K, std::hash<T>, std::equal_to<T>, PairAllocWrapper<T, K>>;

typedef unsigned char* MemBlock;

class BumpAllocator : public ImpAllocator {
private:
    std::shared_ptr<ImpAllocator> mInternalAllocator;
    size_t mSize;
    MemBlock mBlock;
    MemBlock mStart;;
    size_t mCurrent;

public:

    BumpAllocator(size_t pSize, std::shared_ptr<ImpAllocator> pInternalAllocator) :
        mInternalAllocator(pInternalAllocator),
        mSize(pSize),
        mCurrent(0) {
        mBlock = reinterpret_cast<MemBlock>(mInternalAllocator->Allocate(pSize));
        mStart = mBlock;
    }

    ~BumpAllocator() {
        mInternalAllocator->Free(mBlock);
    }

    void* Allocate(size_t pSize) override {
        printf("\n bump allocator wrapper requested: %d", pSize);
        if (mCurrent + pSize > mSize) {
            return nullptr;
        }
        MemBlock _return = mBlock + mCurrent;
        mCurrent += pSize;
        return _return;
    }

    void Free(void* pFre) override {

    }

    void Reset() {
        mCurrent = 0;
    }
};

struct Animation {

};

struct Texture {

};

struct TextureArrayIndex {
    //TexturePointer mTexture;
    unsigned int mIndex;
    std::shared_ptr<Texture> mTexture;
};

struct RenderOrder {
    float mDeltaTime;
    std::string mAnimationName;
    std::shared_ptr<Animation> mAnim;
};

using Textures = AllocatedUnorderedMap<int, TextureArrayIndex>;
using TexturesAllocWrapper = PairAllocWrapper<int, TextureArrayIndex>;
using RenderOrdersVector = AllocatedVector<RenderOrder>;
using RenderOrdersAllocWrapper = AllocWrapper<RenderOrder>;
using RenderBucket = AllocatedUnorderedMap<unsigned int, RenderOrdersVector>;
using RenderBuckets = AllocatedUnorderedMap<std::shared_ptr<Animation>, RenderBucket>;
using RenderBucketAllocWrapper = PairAllocWrapper<unsigned int, RenderOrdersVector>;
using RenderBucketsAllocWrapper = PairAllocWrapper<std::shared_ptr<Animation>, RenderBucket>;


struct Renderer {

    std::shared_ptr<BumpAllocator> mInternalAllocator;
    Textures mTextureArrayIndexMap;
    RenderBuckets mAnimationRenderBuckets;

    Renderer(std::shared_ptr<ImpAllocator> pAllocator) :
        mInternalAllocator(std::make_shared<BumpAllocator>(60000, pAllocator)),
        mTextureArrayIndexMap(Textures(TexturesAllocWrapper(mInternalAllocator))),
        mAnimationRenderBuckets(RenderBuckets(RenderBucketsAllocWrapper(mInternalAllocator))) 
    {}

    void Begin() {
        mTextureArrayIndexMap = Textures(TexturesAllocWrapper(mInternalAllocator));
        mTextureArrayIndexMap.reserve(2);
        mAnimationRenderBuckets = RenderBuckets(RenderBucketsAllocWrapper(mInternalAllocator));
        mAnimationRenderBuckets.reserve(1000);
    }

    void Render() {

    }

    void Flush() {
        mInternalAllocator->Reset();
    }

};

int main(int argc, char* argv[]) {

    Renderer _renderer(std::make_shared<SysAllocator>());

    for (int i = 0; i < 1000; i++) {
        _renderer.Begin();
        _renderer.Flush();
    }
}

奇怪的是，前两次迭代工作正常。但是第三个失败了......因此，重用内存适用于前 2 个 Begin--->Flush 周期，但随后第 3 个周期每次都会失败。太奇怪了。

Answer 1

我无法使用给定的代码重现错误...但代码不使用 std::unordered_map，因此错误必定来自那里。

第一期。在你的分配器中:

void* SysAllocator::Allocate(size_t pSize) override {
    return malloc(pSize);   // allocator returns NULL on error.
  
}

void* BumpAllocator::Allocate(size_t pSize) override {
    printf("\n bump allocator wrapper requested: %d", pSize);
    if (mCurrent + pSize > mSize) {
        return nullptr;     // allocator returns NULL on error.
    }
    MemBlock _return = mBlock + mCurrent;
    mCurrent += pSize;
    return _return;
}

您的自定义分配器在出错时返回 NULL，但 STL 容器希望其分配器在出错时抛出 std::bad_alloc 异常。这是强制性。

您应该更改分配器:

void* SysAllocator::Allocate(size_t pSize) override {
    void* p = malloc(pSize);
    if (!p)
        throw std::bad_alloc();
    return p;
}

void* BumpAllocator::Allocate(size_t pSize) override {
    printf("\n bump allocator wrapper requested: %d", pSize);
    if (mCurrent + pSize > mSize)
        throw std::bad_alloc();
    MemBlock _return = mBlock + mCurrent;
    mCurrent += pSize;
    return _return;
}

这不会解决您的问题，但错误点将转移到分配时。

我认为你的问题来自于缺乏内存。 std::unordered_map 使用哈希桶，这些桶很可能使用比您预期更多的内存。要进行调查，请在 Allocate() 函数中的 throw 行上设置断点，以便在错误发生时立即捕获它。