Add a ResourceMap class for faster GL resource maps.

src/libANGLE/Context.cpp

@@ -409,6 +409,7 @@ egl::Error Context::onDestroy(const egl::Display *display)
     {
         SafeDelete(fence.second);
     }
+    mFenceNVMap.clear();
 
     for (auto query : mQueryMap)
     {
@@ -417,6 +418,7 @@ egl::Error Context::onDestroy(const egl::Display *display)
             query.second->release(this);
         }
     }
+    mQueryMap.clear();
 
     for (auto vertexArray : mVertexArrayMap)
     {
@@ -425,6 +427,7 @@ egl::Error Context::onDestroy(const egl::Display *display)
             vertexArray.second->onDestroy(this);
         }
     }
+    mVertexArrayMap.clear();
 
     for (auto transformFeedback : mTransformFeedbackMap)
     {
@@ -433,6 +436,7 @@ egl::Error Context::onDestroy(const egl::Display *display)
             transformFeedback.second->release(this);
         }
     }
+    mTransformFeedbackMap.clear();
 
     for (auto &zeroTexture : mZeroTextures)
     {
@@ -607,7 +611,7 @@ GLuint Context::createPaths(GLsizei range)
 GLuint Context::createVertexArray()
 {
     GLuint vertexArray = mVertexArrayHandleAllocator.allocate();
-    mVertexArrayMap[vertexArray] = nullptr;
+    mVertexArrayMap.assign(vertexArray, nullptr);
     return vertexArray;
 }
 
@@ -619,7 +623,7 @@ GLuint Context::createSampler()
 GLuint Context::createTransformFeedback()
 {
     GLuint transformFeedback = mTransformFeedbackAllocator.allocate();
-    mTransformFeedbackMap[transformFeedback] = nullptr;
+    mTransformFeedbackMap.assign(transformFeedback, nullptr);
     return transformFeedback;
 }
 
@@ -632,9 +636,7 @@ GLuint Context::createFramebuffer()
 GLuint Context::createFenceNV()
 {
     GLuint handle = mFenceNVHandleAllocator.allocate();
-
-    mFenceNVMap[handle] = new FenceNV(mImplementation->createFenceNV());
-
+    mFenceNVMap.assign(handle, new FenceNV(mImplementation->createFenceNV()));
     return handle;
 }
 
@@ -642,9 +644,7 @@ GLuint Context::createFenceNV()
 GLuint Context::createQuery()
 {
     GLuint handle = mQueryHandleAllocator.allocate();
-
-    mQueryMap[handle] = nullptr;
-
+    mQueryMap.assign(handle, nullptr);
     return handle;
 }
 
@@ -790,17 +790,15 @@ void Context::setPathStencilFunc(GLenum func, GLint ref, GLuint mask)
 
 void Context::deleteVertexArray(GLuint vertexArray)
 {
-    auto iter = mVertexArrayMap.find(vertexArray);
-    if (iter != mVertexArrayMap.end())
+    VertexArray *vertexArrayObject = nullptr;
+    if (mVertexArrayMap.erase(vertexArray, &vertexArrayObject))
     {
-        VertexArray *vertexArrayObject = iter->second;
         if (vertexArrayObject != nullptr)
         {
             detachVertexArray(vertexArray);
             vertexArrayObject->onDestroy(this);
         }
 
-        mVertexArrayMap.erase(iter);
         mVertexArrayHandleAllocator.release(vertexArray);
     }
 }
@@ -822,17 +820,15 @@ void Context::deleteTransformFeedback(GLuint transformFeedback)
         return;
     }
 
-    auto iter = mTransformFeedbackMap.find(transformFeedback);
-    if (iter != mTransformFeedbackMap.end())
+    TransformFeedback *transformFeedbackObject = nullptr;
+    if (mTransformFeedbackMap.erase(transformFeedback, &transformFeedbackObject))
     {
-        TransformFeedback *transformFeedbackObject = iter->second;
         if (transformFeedbackObject != nullptr)
         {
             detachTransformFeedback(transformFeedback);
             transformFeedbackObject->release(this);
         }
 
-        mTransformFeedbackMap.erase(iter);
         mTransformFeedbackAllocator.release(transformFeedback);
     }
 }
@@ -849,27 +845,24 @@ void Context::deleteFramebuffer(GLuint framebuffer)
 
 void Context::deleteFenceNV(GLuint fence)
 {
-    auto fenceObject = mFenceNVMap.find(fence);
-
-    if (fenceObject != mFenceNVMap.end())
+    FenceNV *fenceObject = nullptr;
+    if (mFenceNVMap.erase(fence, &fenceObject))
     {
-        mFenceNVHandleAllocator.release(fenceObject->first);
-        delete fenceObject->second;
-        mFenceNVMap.erase(fenceObject);
+        mFenceNVHandleAllocator.release(fence);
+        delete fenceObject;
     }
 }
 
 void Context::deleteQuery(GLuint query)
 {
-    auto queryObject = mQueryMap.find(query);
-    if (queryObject != mQueryMap.end())
+    Query *queryObject = nullptr;
+    if (mQueryMap.erase(query, &queryObject))
     {
-        mQueryHandleAllocator.release(queryObject->first);
-        if (queryObject->second)
+        mQueryHandleAllocator.release(query);
+        if (queryObject)
         {
-            queryObject->second->release(this);
+            queryObject->release(this);
         }
-        mQueryMap.erase(queryObject);
     }
 }
 
@@ -896,8 +889,7 @@ FenceSync *Context::getFenceSync(GLsync handle) const
 
 VertexArray *Context::getVertexArray(GLuint handle) const
 {
-    auto vertexArray = mVertexArrayMap.find(handle);
-    return (vertexArray != mVertexArrayMap.end()) ? vertexArray->second : nullptr;
+    return mVertexArrayMap.query(handle);
 }
 
 Sampler *Context::getSampler(GLuint handle) const
@@ -907,8 +899,7 @@ Sampler *Context::getSampler(GLuint handle) const
 
 TransformFeedback *Context::getTransformFeedback(GLuint handle) const
 {
-    auto iter = mTransformFeedbackMap.find(handle);
-    return (iter != mTransformFeedbackMap.end()) ? iter->second : nullptr;
+    return mTransformFeedbackMap.query(handle);
 }
 
 LabeledObject *Context::getLabeledObject(GLenum identifier, GLuint name) const
@@ -1270,41 +1261,29 @@ Framebuffer *Context::getFramebuffer(GLuint handle) const
 
 FenceNV *Context::getFenceNV(GLuint handle)
 {
-    auto fence = mFenceNVMap.find(handle);
-
-    if (fence == mFenceNVMap.end())
-    {
-        return nullptr;
-    }
-    else
-    {
-        return fence->second;
-    }
+    return mFenceNVMap.query(handle);
 }
 
 Query *Context::getQuery(GLuint handle, bool create, GLenum type)
 {
-    auto query = mQueryMap.find(handle);
-
-    if (query == mQueryMap.end())
+    if (!mQueryMap.contains(handle))
     {
         return nullptr;
     }
-    else
-    {
-        if (!query->second && create)
+
+    Query *query = mQueryMap.query(handle);
+    if (!query && create)
     {
-            query->second = new Query(mImplementation->createQuery(type), handle);
-            query->second->addRef();
-        }
-        return query->second;
+        query = new Query(mImplementation->createQuery(type), handle);
+        query->addRef();
+        mQueryMap.assign(handle, query);
     }
+    return query;
 }
 
 Query *Context::getQuery(GLuint handle) const
 {
-    auto iter = mQueryMap.find(handle);
-    return (iter != mQueryMap.end()) ? iter->second : nullptr;
+    return mQueryMap.query(handle);
 }
 
 Texture *Context::getTargetTexture(GLenum target) const
@@ -2309,7 +2288,7 @@ VertexArray *Context::checkVertexArrayAllocation(GLuint vertexArrayHandle)
         vertexArray = new VertexArray(mImplementation.get(), vertexArrayHandle,
                                       mCaps.maxVertexAttributes, mCaps.maxVertexAttribBindings);
 
-        mVertexArrayMap[vertexArrayHandle] = vertexArray;
+        mVertexArrayMap.assign(vertexArrayHandle, vertexArray);
     }
 
     return vertexArray;
@@ -2324,7 +2303,7 @@ TransformFeedback *Context::checkTransformFeedbackAllocation(GLuint transformFee
         transformFeedback =
             new TransformFeedback(mImplementation.get(), transformFeedbackHandle, mCaps);
         transformFeedback->addRef();
-        mTransformFeedbackMap[transformFeedbackHandle] = transformFeedback;
+        mTransformFeedbackMap.assign(transformFeedbackHandle, transformFeedback);
     }
 
     return transformFeedback;
@@ -2332,14 +2311,14 @@ TransformFeedback *Context::checkTransformFeedbackAllocation(GLuint transformFee
 
 bool Context::isVertexArrayGenerated(GLuint vertexArray)
 {
-    ASSERT(mVertexArrayMap.find(0) != mVertexArrayMap.end());
-    return mVertexArrayMap.find(vertexArray) != mVertexArrayMap.end();
+    ASSERT(mVertexArrayMap.contains(0));
+    return mVertexArrayMap.contains(vertexArray);
 }
 
 bool Context::isTransformFeedbackGenerated(GLuint transformFeedback)
 {
-    ASSERT(mTransformFeedbackMap.find(0) != mTransformFeedbackMap.end());
-    return mTransformFeedbackMap.find(transformFeedback) != mTransformFeedbackMap.end();
+    ASSERT(mTransformFeedbackMap.contains(0));
+    return mTransformFeedbackMap.contains(transformFeedback);
 }
 
 void Context::detachTexture(GLuint texture)

src/libANGLE/Context.h

@@ -22,6 +22,7 @@
 #include "libANGLE/Error.h"
 #include "libANGLE/HandleAllocator.h"
 #include "libANGLE/RefCountObject.h"
+#include "libANGLE/ResourceMap.h"
 #include "libANGLE/VertexAttribute.h"
 #include "libANGLE/Workarounds.h"
 #include "libANGLE/angletypes.h"

src/libANGLE/HandleAllocator.cpp

@@ -128,4 +128,13 @@ void HandleAllocator::reserve(GLuint handle)
     mUnallocatedList.insert(placementIt, HandleRange(begin, handle - 1));
 }
 
+void HandleAllocator::reset()
+{
+    mUnallocatedList.clear();
+    mUnallocatedList.push_back(HandleRange(1, std::numeric_limits<GLuint>::max()));
+    mReleasedList.clear();
+    mBaseValue = 1;
+    mNextValue = 1;
+}
+
 }  // namespace gl

src/libANGLE/HandleAllocator.h

@@ -24,7 +24,7 @@ class HandleAllocator final : angle::NonCopyable
   public:
     // Maximum handle = MAX_UINT-1
     HandleAllocator();
-    // Specify maximum handle value
+    // Specify maximum handle value. Used for testing.
     HandleAllocator(GLuint maximumHandleValue);
 
     ~HandleAllocator();
@@ -34,6 +34,7 @@ class HandleAllocator final : angle::NonCopyable
     GLuint allocate();
     void release(GLuint handle);
     void reserve(GLuint handle);
+    void reset();
 
   private:
     GLuint mBaseValue;

src/libANGLE/HandleAllocator_unittest.cpp

@@ -135,4 +135,19 @@ TEST(HandleAllocatorTest, SortedOrderHandle)
     EXPECT_EQ(6u, allocatedList[4]);
 }
 
+// Tests the reset method.
+TEST(HandleAllocatorTest, Reset)
+{
+    gl::HandleAllocator allocator;
+
+    for (int iteration = 0; iteration < 1; ++iteration)
+    {
+        allocator.reserve(3);
+        EXPECT_EQ(1u, allocator.allocate());
+        EXPECT_EQ(2u, allocator.allocate());
+        EXPECT_EQ(4u, allocator.allocate());
+        allocator.reset();
+    }
 }
+
+}  // anonymous namespace

src/libANGLE/ResourceManager.cpp

@@ -29,17 +29,10 @@ template <typename ResourceType>
 GLuint AllocateEmptyObject(HandleAllocator *handleAllocator, ResourceMap<ResourceType> *objectMap)
 {
     GLuint handle = handleAllocator->allocate();
-    (*objectMap)[handle] = nullptr;
+    objectMap->assign(handle, nullptr);
     return handle;
 }
 
-template <typename ResourceType>
-ResourceType *GetObject(const ResourceMap<ResourceType> &objectMap, GLuint handle)
-{
-    auto iter = objectMap.find(handle);
-    return iter != objectMap.end() ? iter->second : nullptr;
-}
-
 }  // anonymous namespace
 
 template <typename HandleAllocatorType>
@@ -72,9 +65,13 @@ TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::~TypedResourceMa
 template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
 void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::reset(const Context *context)
 {
-    while (!mObjectMap.empty())
+    this->mHandleAllocator.reset();
+    for (const auto &resource : mObjectMap)
+    {
+        if (resource.second)
         {
-        deleteObject(context, mObjectMap.begin()->first);
+            ImplT::DeleteObject(context, resource.second);
+        }
     }
     mObjectMap.clear();
 }
@@ -84,77 +81,29 @@ void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::deleteObjec
     const Context *context,
     GLuint handle)
 {
-    auto objectIter = mObjectMap.find(handle);
-    if (objectIter == mObjectMap.end())
+    ResourceType *resource = nullptr;
+    if (!mObjectMap.erase(handle, &resource))
     {
         return;
     }
 
-    if (objectIter->second != nullptr)
-    {
-        ImplT::DeleteObject(context, objectIter->second);
-    }
-
     // Requires an explicit this-> because of C++ template rules.
-    this->mHandleAllocator.release(objectIter->first);
-    mObjectMap.erase(objectIter);
-}
+    this->mHandleAllocator.release(handle);
 
-template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
-template <typename... ArgTypes>
-ResourceType *TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::allocateObject(
-    typename ResourceMap<ResourceType>::iterator &objectMapIter,
-    rx::GLImplFactory *factory,
-    GLuint handle,
-    ArgTypes... args)
-{
-    ResourceType *object = ImplT::AllocateNewObject(factory, handle, args...);
-
-    if (objectMapIter != mObjectMap.end())
+    if (resource)
     {
-        objectMapIter->second = object;
+        ImplT::DeleteObject(context, resource);
     }
-    else
-    {
-        this->mHandleAllocator.reserve(handle);
-        mObjectMap[handle] = object;
-    }
-
-    return object;
 }
 
 template class ResourceManagerBase<HandleAllocator>;
 template class ResourceManagerBase<HandleRangeAllocator>;
 template class TypedResourceManager<Buffer, HandleAllocator, BufferManager>;
-template Buffer *TypedResourceManager<Buffer, HandleAllocator, BufferManager>::allocateObject(
-    ResourceMap<Buffer>::iterator &,
-    rx::GLImplFactory *,
-    GLuint);
 template class TypedResourceManager<Texture, HandleAllocator, TextureManager>;
-template Texture *TypedResourceManager<Texture, HandleAllocator, TextureManager>::allocateObject(
-    ResourceMap<Texture>::iterator &,
-    rx::GLImplFactory *,
-    GLuint,
-    GLenum);
 template class TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>;
-template Renderbuffer *
-TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>::allocateObject(
-    ResourceMap<Renderbuffer>::iterator &,
-    rx::GLImplFactory *,
-    GLuint);
 template class TypedResourceManager<Sampler, HandleAllocator, SamplerManager>;
-template Sampler *TypedResourceManager<Sampler, HandleAllocator, SamplerManager>::allocateObject(
-    ResourceMap<Sampler>::iterator &,
-    rx::GLImplFactory *,
-    GLuint);
 template class TypedResourceManager<FenceSync, HandleAllocator, FenceSyncManager>;
 template class TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>;
-template Framebuffer *
-TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>::allocateObject(
-    ResourceMap<Framebuffer>::iterator &,
-    rx::GLImplFactory *,
-    GLuint,
-    const Caps &);
 
 // BufferManager Implementation.
 
@@ -179,7 +128,7 @@ GLuint BufferManager::createBuffer()
 
 Buffer *BufferManager::getBuffer(GLuint handle) const
 {
-    return GetObject(mObjectMap, handle);
+    return mObjectMap.query(handle);
 }
 
 // ShaderProgramManager Implementation.
@@ -210,7 +159,7 @@ GLuint ShaderProgramManager::createShader(rx::GLImplFactory *factory,
 {
     ASSERT(type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER || type == GL_COMPUTE_SHADER);
     GLuint handle    = mHandleAllocator.allocate();
-    mShaders[handle] = new Shader(this, factory, rendererLimitations, type, handle);
+    mShaders.assign(handle, new Shader(this, factory, rendererLimitations, type, handle));
     return handle;
 }
 
@@ -221,13 +170,13 @@ void ShaderProgramManager::deleteShader(const Context *context, GLuint shader)
 
 Shader *ShaderProgramManager::getShader(GLuint handle) const
 {
-    return GetObject(mShaders, handle);
+    return mShaders.query(handle);
 }
 
 GLuint ShaderProgramManager::createProgram(rx::GLImplFactory *factory)
 {
     GLuint handle = mHandleAllocator.allocate();
-    mPrograms[handle] = new Program(factory, this, handle);
+    mPrograms.assign(handle, new Program(factory, this, handle));
     return handle;
 }
 
@@ -238,7 +187,7 @@ void ShaderProgramManager::deleteProgram(const gl::Context *context, GLuint prog
 
 Program *ShaderProgramManager::getProgram(GLuint handle) const
 {
-    return GetObject(mPrograms, handle);
+    return mPrograms.query(handle);
 }
 
 template <typename ObjectType>
@@ -246,18 +195,17 @@ void ShaderProgramManager::deleteObject(const Context *context,
                                         ResourceMap<ObjectType> *objectMap,
                                         GLuint id)
 {
-    auto iter = objectMap->find(id);
-    if (iter == objectMap->end())
+    ObjectType *object = objectMap->query(id);
+    if (!object)
     {
         return;
     }
 
-    auto object = iter->second;
     if (object->getRefCount() == 0)
     {
         mHandleAllocator.release(id);
         object->onDestroy(context);
-        objectMap->erase(iter);
+        objectMap->erase(id, &object);
     }
     else
     {
@@ -288,13 +236,13 @@ GLuint TextureManager::createTexture()
 
 Texture *TextureManager::getTexture(GLuint handle) const
 {
-    ASSERT(GetObject(mObjectMap, 0) == nullptr);
-    return GetObject(mObjectMap, handle);
+    ASSERT(mObjectMap.query(0) == nullptr);
+    return mObjectMap.query(handle);
 }
 
-void TextureManager::invalidateTextureComplenessCache()
+void TextureManager::invalidateTextureComplenessCache() const
 {
-    for (auto &texture : mObjectMap)
+    for (const auto &texture : mObjectMap)
     {
         if (texture.second)
         {
@@ -326,7 +274,7 @@ GLuint RenderbufferManager::createRenderbuffer()
 
 Renderbuffer *RenderbufferManager::getRenderbuffer(GLuint handle)
 {
-    return GetObject(mObjectMap, handle);
+    return mObjectMap.query(handle);
 }
 
 // SamplerManager Implementation.
@@ -352,12 +300,12 @@ GLuint SamplerManager::createSampler()
 
 Sampler *SamplerManager::getSampler(GLuint handle)
 {
-    return GetObject(mObjectMap, handle);
+    return mObjectMap.query(handle);
 }
 
 bool SamplerManager::isSampler(GLuint sampler)
 {
-    return mObjectMap.find(sampler) != mObjectMap.end();
+    return mObjectMap.contains(sampler);
 }
 
 // FenceSyncManager Implementation.
@@ -373,13 +321,13 @@ GLuint FenceSyncManager::createFenceSync(rx::GLImplFactory *factory)
     GLuint handle        = mHandleAllocator.allocate();
     FenceSync *fenceSync = new FenceSync(factory->createFenceSync(), handle);
     fenceSync->addRef();
-    mObjectMap[handle] = fenceSync;
+    mObjectMap.assign(handle, fenceSync);
     return handle;
 }
 
 FenceSync *FenceSyncManager::getFenceSync(GLuint handle)
 {
-    return GetObject(mObjectMap, handle);
+    return mObjectMap.query(handle);
 }
 
 // PathManager Implementation.
@@ -398,13 +346,11 @@ ErrorOrResult<GLuint> PathManager::createPaths(rx::GLImplFactory *factory, GLsiz
         return OutOfMemory() << "Failed to allocate path objects.";
     }
 
-    auto hint = mPaths.begin();
-
     for (GLsizei i = 0; i < range; ++i)
     {
         const auto impl = paths[static_cast<unsigned>(i)];
         const auto id   = client + i;
-        hint            = mPaths.insert(hint, std::make_pair(id, new Path(impl)));
+        mPaths.assign(id, new Path(impl));
     }
     return client;
 }
@@ -414,20 +360,17 @@ void PathManager::deletePaths(GLuint first, GLsizei range)
     for (GLsizei i = 0; i < range; ++i)
     {
         const auto id = first + i;
-        const auto it = mPaths.find(id);
-        if (it == mPaths.end())
+        Path *p       = nullptr;
+        if (!mPaths.erase(id, &p))
             continue;
-        Path *p = it->second;
         delete p;
-        mPaths.erase(it);
     }
     mHandleAllocator.releaseRange(first, static_cast<GLuint>(range));
 }
 
 Path *PathManager::getPath(GLuint handle) const
 {
-    auto iter = mPaths.find(handle);
-    return iter != mPaths.end() ? iter->second : nullptr;
+    return mPaths.query(handle);
 }
 
 bool PathManager::hasPath(GLuint handle) const
@@ -477,18 +420,18 @@ GLuint FramebufferManager::createFramebuffer()
 
 Framebuffer *FramebufferManager::getFramebuffer(GLuint handle) const
 {
-    return GetObject(mObjectMap, handle);
+    return mObjectMap.query(handle);
 }
 
 void FramebufferManager::setDefaultFramebuffer(Framebuffer *framebuffer)
 {
     ASSERT(framebuffer == nullptr || framebuffer->id() == 0);
-    mObjectMap[0] = framebuffer;
+    mObjectMap.assign(0, framebuffer);
 }
 
-void FramebufferManager::invalidateFramebufferComplenessCache()
+void FramebufferManager::invalidateFramebufferComplenessCache() const
 {
-    for (auto &framebuffer : mObjectMap)
+    for (const auto &framebuffer : mObjectMap)
     {
         if (framebuffer.second)
         {

src/libANGLE/ResourceManager.h

@@ -12,10 +12,10 @@
 
 #include "angle_gl.h"
 #include "common/angleutils.h"
-#include "libANGLE/angletypes.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/HandleAllocator.h"
 #include "libANGLE/HandleRangeAllocator.h"
+#include "libANGLE/ResourceMap.h"
 
 namespace rx
 {
@@ -66,7 +66,7 @@ class TypedResourceManager : public ResourceManagerBase<HandleAllocatorType>
     bool isHandleGenerated(GLuint handle) const
     {
         // Zero is always assumed to have been generated implicitly.
-        return handle == 0 || mObjectMap.find(handle) != mObjectMap.end();
+        return handle == 0 || mObjectMap.contains(handle);
     }
 
   protected:
@@ -76,11 +76,10 @@ class TypedResourceManager : public ResourceManagerBase<HandleAllocatorType>
     template <typename... ArgTypes>
     ResourceType *checkObjectAllocation(rx::GLImplFactory *factory, GLuint handle, ArgTypes... args)
     {
-        auto objectMapIter = mObjectMap.find(handle);
-
-        if (objectMapIter != mObjectMap.end() && objectMapIter->second != nullptr)
+        ResourceType *value = mObjectMap.query(handle);
+        if (value)
         {
-            return objectMapIter->second;
+            return value;
         }
 
         if (handle == 0)
@@ -88,14 +87,16 @@ class TypedResourceManager : public ResourceManagerBase<HandleAllocatorType>
             return nullptr;
         }
 
-        return allocateObject<ArgTypes...>(objectMapIter, factory, handle, args...);
+        ResourceType *object = ImplT::AllocateNewObject(factory, handle, args...);
+
+        if (!mObjectMap.contains(handle))
+        {
+            this->mHandleAllocator.reserve(handle);
         }
+        mObjectMap.assign(handle, object);
 
-    template <typename... ArgTypes>
-    ResourceType *allocateObject(typename ResourceMap<ResourceType>::iterator &objectMapIter,
-                                 rx::GLImplFactory *factory,
-                                 GLuint handle,
-                                 ArgTypes... args);
+        return object;
+    }
 
     void reset(const Context *context) override;
 
@@ -153,7 +154,7 @@ class TextureManager : public TypedResourceManager<Texture, HandleAllocator, Tex
     GLuint createTexture();
     Texture *getTexture(GLuint handle) const;
 
-    void invalidateTextureComplenessCache();
+    void invalidateTextureComplenessCache() const;
 
     Texture *checkTextureAllocation(rx::GLImplFactory *factory, GLuint handle, GLenum target)
     {
@@ -241,7 +242,7 @@ class FramebufferManager
     Framebuffer *getFramebuffer(GLuint handle) const;
     void setDefaultFramebuffer(Framebuffer *framebuffer);
 
-    void invalidateFramebufferComplenessCache();
+    void invalidateFramebufferComplenessCache() const;
 
     Framebuffer *checkFramebufferAllocation(rx::GLImplFactory *factory,
                                             const Caps &caps,

src/libANGLE/ResourceMap.h

+//
+// Copyright 2017 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ResourceMap:
+//   An optimized resource map which packs the first set of allocated objects into a
+//   flat array, and then falls back to an unordered map for the higher handle values.
+//
+
+#ifndef LIBANGLE_RESOURCE_MAP_H_
+#define LIBANGLE_RESOURCE_MAP_H_
+
+#include "libANGLE/angletypes.h"
+
+namespace gl
+{
+
+template <typename ResourceType>
+class ResourceMap final : angle::NonCopyable
+{
+  public:
+    ResourceMap();
+    ~ResourceMap();
+
+    ResourceType *query(GLuint handle) const;
+
+    // Returns true if the handle was reserved. Not necessarily if the resource is created.
+    bool contains(GLuint handle) const;
+
+    // Returns the element that was at this location.
+    bool erase(GLuint handle, ResourceType **resourceOut);
+
+    void assign(GLuint handle, ResourceType *resource);
+
+    // Clears the map.
+    void clear();
+
+    using IndexAndResource = std::pair<GLuint, ResourceType *>;
+    using HashMap          = std::unordered_map<GLuint, ResourceType *>;
+
+    class Iterator final
+    {
+      public:
+        bool operator==(const Iterator &other) const;
+        bool operator!=(const Iterator &other) const;
+        Iterator &operator++();
+        const IndexAndResource *operator->() const;
+        const IndexAndResource &operator*() const;
+
+      private:
+        friend class ResourceMap;
+        Iterator(const ResourceMap &origin,
+                 GLuint flatIndex,
+                 typename HashMap::const_iterator hashIndex);
+        void updateValue();
+
+        const ResourceMap &mOrigin;
+        GLuint mFlatIndex;
+        typename HashMap::const_iterator mHashIndex;
+        IndexAndResource mValue;
+    };
+
+    // null values represent reserved handles.
+    Iterator begin() const;
+    Iterator end() const;
+    Iterator find(GLuint handle) const;
+
+    // Not a constant-time operation, should only be used for verification.
+    bool empty() const;
+
+  private:
+    friend class Iterator;
+
+    GLuint nextNonNullResource(size_t flatIndex) const;
+
+    // constexpr methods cannot contain reinterpret_cast, so we need a static method.
+    static ResourceType *InvalidPointer();
+    static constexpr intptr_t kInvalidPointer = static_cast<intptr_t>(-1);
+
+    // Start with 32 maximum elements in the map, which can grow.
+    static constexpr size_t kInitialFlatResourcesSize = 0x20;
+
+    // Experimental testing suggests that 16k is a reasonable upper limit.
+    static constexpr size_t kFlatResourcesLimit = 0x4000;
+
+    std::vector<ResourceType *> mFlatResources;
+
+    // A map of GL objects indexed by object ID.
+    HashMap mHashedResources;
+};
+
+template <typename ResourceType>
+ResourceMap<ResourceType>::ResourceMap()
+    : mFlatResources(kInitialFlatResourcesSize, InvalidPointer()), mHashedResources()
+{
+}
+
+template <typename ResourceType>
+ResourceMap<ResourceType>::~ResourceMap()
+{
+    ASSERT(empty());
+}
+
+template <typename ResourceType>
+ResourceType *ResourceMap<ResourceType>::query(GLuint handle) const
+{
+    if (handle < mFlatResources.size())
+    {
+        auto value = mFlatResources[handle];
+        return (value == InvalidPointer() ? nullptr : value);
+    }
+    auto it = mHashedResources.find(handle);
+    return (it == mHashedResources.end() ? nullptr : it->second);
+}
+
+template <typename ResourceType>
+bool ResourceMap<ResourceType>::contains(GLuint handle) const
+{
+    if (handle < mFlatResources.size())
+    {
+        return (mFlatResources[handle] != InvalidPointer());
+    }
+    return (mHashedResources.find(handle) != mHashedResources.end());
+}
+
+template <typename ResourceType>
+bool ResourceMap<ResourceType>::erase(GLuint handle, ResourceType **resourceOut)
+{
+    if (handle < mFlatResources.size())
+    {
+        auto &value = mFlatResources[handle];
+        if (value == InvalidPointer())
+        {
+            return false;
+        }
+        *resourceOut = value;
+        value        = InvalidPointer();
+    }
+    else
+    {
+        auto it = mHashedResources.find(handle);
+        if (it == mHashedResources.end())
+        {
+            return false;
+        }
+        *resourceOut = it->second;
+        mHashedResources.erase(it);
+    }
+    return true;
+}
+
+template <typename ResourceType>
+void ResourceMap<ResourceType>::assign(GLuint handle, ResourceType *resource)
+{
+    if (handle < kFlatResourcesLimit)
+    {
+        if (handle >= mFlatResources.size())
+        {
+            // Use power-of-two.
+            size_t newSize = mFlatResources.size();
+            while (newSize <= handle)
+            {
+                newSize *= 2;
+            }
+            mFlatResources.resize(newSize, nullptr);
+        }
+        ASSERT(mFlatResources.size() > handle);
+        mFlatResources[handle] = resource;
+    }
+    else
+    {
+        mHashedResources[handle] = resource;
+    }
+}
+
+template <typename ResourceType>
+typename ResourceMap<ResourceType>::Iterator ResourceMap<ResourceType>::begin() const
+{
+    return Iterator(*this, nextNonNullResource(0), mHashedResources.begin());
+}
+
+template <typename ResourceType>
+typename ResourceMap<ResourceType>::Iterator ResourceMap<ResourceType>::end() const
+{
+    return Iterator(*this, static_cast<GLuint>(mFlatResources.size()), mHashedResources.end());
+}
+
+template <typename ResourceType>
+typename ResourceMap<ResourceType>::Iterator ResourceMap<ResourceType>::find(GLuint handle) const
+{
+    if (handle < mFlatResources.size())
+    {
+        return (mFlatResources[handle] != InvalidPointer()
+                    ? Iterator(handle, mHashedResources.begin())
+                    : end());
+    }
+    else
+    {
+        return mHashedResources.find(handle);
+    }
+}
+
+template <typename ResourceType>
+bool ResourceMap<ResourceType>::empty() const
+{
+    return (begin() == end());
+}
+
+template <typename ResourceType>
+void ResourceMap<ResourceType>::clear()
+{
+    mFlatResources.assign(kInitialFlatResourcesSize, InvalidPointer());
+    mHashedResources.clear();
+}
+
+template <typename ResourceType>
+GLuint ResourceMap<ResourceType>::nextNonNullResource(size_t flatIndex) const
+{
+    for (size_t index = flatIndex; index < mFlatResources.size(); index++)
+    {
+        if (mFlatResources[index] != nullptr && mFlatResources[index] != InvalidPointer())
+        {
+            return static_cast<GLuint>(index);
+        }
+    }
+    return static_cast<GLuint>(mFlatResources.size());
+}
+
+template <typename ResourceType>
+// static
+ResourceType *ResourceMap<ResourceType>::InvalidPointer()
+{
+    return reinterpret_cast<ResourceType *>(kInvalidPointer);
+}
+
+template <typename ResourceType>
+ResourceMap<ResourceType>::Iterator::Iterator(
+    const ResourceMap &origin,
+    GLuint flatIndex,
+    typename ResourceMap<ResourceType>::HashMap::const_iterator hashIndex)
+    : mOrigin(origin), mFlatIndex(flatIndex), mHashIndex(hashIndex), mValue()
+{
+    updateValue();
+}
+
+template <typename ResourceType>
+bool ResourceMap<ResourceType>::Iterator::operator==(const Iterator &other) const
+{
+    return (mFlatIndex == other.mFlatIndex && mHashIndex == other.mHashIndex);
+}
+
+template <typename ResourceType>
+bool ResourceMap<ResourceType>::Iterator::operator!=(const Iterator &other) const
+{
+    return !(*this == other);
+}
+
+template <typename ResourceType>
+typename ResourceMap<ResourceType>::Iterator &ResourceMap<ResourceType>::Iterator::operator++()
+{
+    if (mFlatIndex < static_cast<GLuint>(mOrigin.mFlatResources.size()))
+    {
+        mFlatIndex = mOrigin.nextNonNullResource(mFlatIndex + 1);
+    }
+    else
+    {
+        mHashIndex++;
+    }
+    updateValue();
+    return *this;
+}
+
+template <typename ResourceType>
+const typename ResourceMap<ResourceType>::IndexAndResource
+    *ResourceMap<ResourceType>::Iterator::operator->() const
+{
+    return &mValue;
+}
+
+template <typename ResourceType>
+const typename ResourceMap<ResourceType>::IndexAndResource
+    &ResourceMap<ResourceType>::Iterator::operator*() const
+{
+    return mValue;
+}
+
+template <typename ResourceType>
+void ResourceMap<ResourceType>::Iterator::updateValue()
+{
+    if (mFlatIndex < static_cast<GLuint>(mOrigin.mFlatResources.size()))
+    {
+        mValue.first  = mFlatIndex;
+        mValue.second = mOrigin.mFlatResources[mFlatIndex];
+    }
+    else if (mHashIndex != mOrigin.mHashedResources.end())
+    {
+        mValue.first  = mHashIndex->first;
+        mValue.second = mHashIndex->second;
+    }
+}
+
+}  // namespace gl
+
+#endif  // LIBANGLE_RESOURCE_MAP_H_

src/libANGLE/Texture.cpp

@@ -211,7 +211,7 @@ bool TextureState::isSamplerComplete(const SamplerState &samplerState,
     return mCompletenessCache.samplerComplete;
 }
 
-void TextureState::invalidateCompletenessCache()
+void TextureState::invalidateCompletenessCache() const
 {
     mCompletenessCache.context = 0;
 }
@@ -868,7 +868,7 @@ egl::Stream *Texture::getBoundStream() const
     return mBoundStream;
 }
 
-void Texture::invalidateCompletenessCache()
+void Texture::invalidateCompletenessCache() const
 {
     mState.invalidateCompletenessCache();
     mDirtyChannel.signal();

src/libANGLE/Texture.h

@@ -100,7 +100,7 @@ struct TextureState final : private angle::NonCopyable
     bool isCubeComplete() const;
     bool isSamplerComplete(const SamplerState &samplerState, const ContextState &data) const;
 
-    void invalidateCompletenessCache();
+    void invalidateCompletenessCache() const;
 
     const ImageDesc &getImageDesc(GLenum target, size_t level) const;
     const ImageDesc &getImageDesc(const ImageIndex &imageIndex) const;
@@ -358,7 +358,7 @@ class Texture final : public egl::ImageSibling,
     egl::Surface *getBoundSurface() const;
     egl::Stream *getBoundStream() const;
 
-    void invalidateCompletenessCache();
+    void invalidateCompletenessCache() const;
 
     rx::TextureImpl *getImplementation() const { return mTexture; }
 

src/libANGLE/angletypes.h

@@ -320,11 +320,6 @@ using UniformBlockBindingMask = angle::BitSet<IMPLEMENTATION_MAX_COMBINED_SHADER
 // Used in Framebuffer
 using DrawBufferMask = angle::BitSet<IMPLEMENTATION_MAX_DRAW_BUFFERS>;
 
-// A map of GL objects indexed by object ID. The specific map implementation may change.
-// Client code should treat it as a std::map.
-template <class ResourceT>
-using ResourceMap = std::unordered_map<GLuint, ResourceT *>;
-
 using ContextID = uintptr_t;
 }
 

src/libGLESv2.gypi

@@ -174,6 +174,7 @@
             'libANGLE/Renderbuffer.h',
             'libANGLE/ResourceManager.cpp',
             'libANGLE/ResourceManager.h',
+            'libANGLE/ResourceMap.h',
             'libANGLE/Sampler.cpp',
             'libANGLE/Sampler.h',
             'libANGLE/Shader.cpp',