Unifying resource handle allocation code with an allocator optimized for O(1) allocs/releases.

src/build_angle.gyp

@@ -165,6 +165,8 @@
             'libGLESv2/Fence.h',
             'libGLESv2/Framebuffer.cpp',
             'libGLESv2/Framebuffer.h',
+            'libGLESv2/HandleAllocator.cpp',
+            'libGLESv2/HandleAllocator.h',
             'libGLESv2/libGLESv2.cpp',
             'libGLESv2/libGLESv2.def',
             'libGLESv2/main.cpp',

src/common/version.h

 #define MAJOR_VERSION 0
 #define MINOR_VERSION 0
 #define BUILD_VERSION 0
-#define BUILD_REVISION 622
+#define BUILD_REVISION 623
 
 #define STRINGIFY(x) #x
 #define MACRO_STRINGIFY(x) STRINGIFY(x)

src/libGLESv2/Context.cpp

@@ -35,6 +35,8 @@ namespace gl
 {
 Context::Context(const egl::Config *config, const gl::Context *shareContext) : mConfig(config)
 {
+    mFenceHandleAllocator.setBaseHandle(0);
+
     setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
     mState.depthClearValue = 1.0f;
@@ -818,12 +820,7 @@ GLuint Context::createRenderbuffer()
 // Returns an unused framebuffer name
 GLuint Context::createFramebuffer()
 {
-    unsigned int handle = 1;
-
-    while (mFramebufferMap.find(handle) != mFramebufferMap.end())
-    {
-        handle++;
-    }
+    GLuint handle = mFramebufferHandleAllocator.allocate();
 
     mFramebufferMap[handle] = NULL;
 
@@ -832,12 +829,7 @@ GLuint Context::createFramebuffer()
 
 GLuint Context::createFence()
 {
-    unsigned int handle = 0;
-
-    while (mFenceMap.find(handle) != mFenceMap.end())
-    {
-        handle++;
-    }
+    GLuint handle = mFenceHandleAllocator.allocate();
 
     mFenceMap[handle] = new Fence;
 
@@ -892,6 +884,7 @@ void Context::deleteFramebuffer(GLuint framebuffer)
     {
         detachFramebuffer(framebuffer);
 
+        mFramebufferHandleAllocator.release(framebufferObject->first);
         delete framebufferObject->second;
         mFramebufferMap.erase(framebufferObject);
     }
@@ -903,6 +896,7 @@ void Context::deleteFence(GLuint fence)
 
     if (fenceObject != mFenceMap.end())
     {
+        mFenceHandleAllocator.release(fenceObject->first);
         delete fenceObject->second;
         mFenceMap.erase(fenceObject);
     }

src/libGLESv2/Context.h

@@ -21,6 +21,7 @@
 
 #include "common/angleutils.h"
 #include "libGLESv2/ResourceManager.h"
+#include "libGLESv2/HandleAllocator.h"
 #include "libGLESv2/RefCountObject.h"
 
 namespace egl
@@ -480,9 +481,11 @@ class Context
 
     typedef std::map<GLuint, Framebuffer*> FramebufferMap;
     FramebufferMap mFramebufferMap;
+    HandleAllocator mFramebufferHandleAllocator;
 
     typedef std::map<GLuint, Fence*> FenceMap;
     FenceMap mFenceMap;
+    HandleAllocator mFenceHandleAllocator;
 
     void initExtensionString();
     std::string mExtensionString;

src/libGLESv2/HandleAllocator.cpp

+//
+// Copyright (c) 2002-2011 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.
+//
+
+// HandleAllocator.cpp: Implements the gl::HandleAllocator class, which is used
+// to allocate GL handles.
+
+#include "libGLESv2/HandleAllocator.h"
+
+#include "libGLESv2/main.h"
+
+namespace gl
+{
+
+HandleAllocator::HandleAllocator() : mBaseValue(1), mNextValue(1)
+{
+}
+
+HandleAllocator::~HandleAllocator()
+{
+}
+
+void HandleAllocator::setBaseHandle(GLuint value)
+{
+    ASSERT(mBaseValue == mNextValue);
+    mBaseValue = value;
+    mNextValue = value;
+}
+
+GLuint HandleAllocator::allocate()
+{
+    if (mFreeValues.size())
+    {
+        GLuint handle = mFreeValues.back();
+        mFreeValues.pop_back();
+        return handle;
+    }
+    return mNextValue++;
+}
+
+void HandleAllocator::release(GLuint handle)
+{
+    if (handle == mNextValue - 1)
+    {
+        ASSERT(mBaseValue < mNextValue);
+        mNextValue--;
+        return;
+    }
+    mFreeValues.push_back(handle);
+}
+
+}

src/libGLESv2/HandleAllocator.h

+//
+// Copyright (c) 2002-2011 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.
+//
+
+// HandleAllocator.h: Defines the gl::HandleAllocator class, which is used to
+// allocate GL handles.
+
+#ifndef LIBGLESV2_HANDLEALLOCATOR_H_
+#define LIBGLESV2_HANDLEALLOCATOR_H_
+
+#define GL_APICALL
+#include <GLES2/gl2.h>
+
+#include <vector>
+
+#include "common/angleutils.h"
+
+namespace gl
+{
+
+class HandleAllocator
+{
+  public:
+    HandleAllocator();
+    virtual ~HandleAllocator();
+
+    void setBaseHandle(GLuint value);
+
+    GLuint allocate();
+    void release(GLuint handle);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(HandleAllocator);
+
+    GLuint mBaseValue;
+    GLuint mNextValue;
+    typedef std::vector<GLuint> HandleList;
+    HandleList mFreeValues;
+};
+
+}
+
+#endif   // LIBGLESV2_HANDLEALLOCATOR_H_

src/libGLESv2/ResourceManager.cpp

@@ -66,12 +66,7 @@ void ResourceManager::release()
 // Returns an unused buffer name
 GLuint ResourceManager::createBuffer()
 {
-    unsigned int handle = 1;
-
-    while (mBufferMap.find(handle) != mBufferMap.end())
-    {
-        handle++;
-    }
+    GLuint handle = mBufferHandleAllocator.allocate();
 
     mBufferMap[handle] = NULL;
 
@@ -81,12 +76,7 @@ GLuint ResourceManager::createBuffer()
 // Returns an unused shader/program name
 GLuint ResourceManager::createShader(GLenum type)
 {
-    unsigned int handle = 1;
-
-    while (mShaderMap.find(handle) != mShaderMap.end() || mProgramMap.find(handle) != mProgramMap.end())   // Shared name space
-    {
-        handle++;
-    }
+    GLuint handle = mProgramShaderHandleAllocator.allocate();
 
     if (type == GL_VERTEX_SHADER)
     {
@@ -104,12 +94,7 @@ GLuint ResourceManager::createShader(GLenum type)
 // Returns an unused program/shader name
 GLuint ResourceManager::createProgram()
 {
-    unsigned int handle = 1;
-
-    while (mProgramMap.find(handle) != mProgramMap.end() || mShaderMap.find(handle) != mShaderMap.end())   // Shared name space
-    {
-        handle++;
-    }
+    GLuint handle = mProgramShaderHandleAllocator.allocate();
 
     mProgramMap[handle] = new Program(this, handle);
 
@@ -119,12 +104,7 @@ GLuint ResourceManager::createProgram()
 // Returns an unused texture name
 GLuint ResourceManager::createTexture()
 {
-    unsigned int handle = 1;
-
-    while (mTextureMap.find(handle) != mTextureMap.end())
-    {
-        handle++;
-    }
+    GLuint handle = mTextureHandleAllocator.allocate();
 
     mTextureMap[handle] = NULL;
 
@@ -134,12 +114,7 @@ GLuint ResourceManager::createTexture()
 // Returns an unused renderbuffer name
 GLuint ResourceManager::createRenderbuffer()
 {
-    unsigned int handle = 1;
-
-    while (mRenderbufferMap.find(handle) != mRenderbufferMap.end())
-    {
-        handle++;
-    }
+    GLuint handle = mRenderbufferHandleAllocator.allocate();
 
     mRenderbufferMap[handle] = NULL;
 
@@ -152,6 +127,7 @@ void ResourceManager::deleteBuffer(GLuint buffer)
 
     if (bufferObject != mBufferMap.end())
     {
+        mBufferHandleAllocator.release(bufferObject->first);
         if (bufferObject->second) bufferObject->second->release();
         mBufferMap.erase(bufferObject);
     }
@@ -165,6 +141,7 @@ void ResourceManager::deleteShader(GLuint shader)
     {
         if (shaderObject->second->getRefCount() == 0)
         {
+            mProgramShaderHandleAllocator.release(shaderObject->first);
             delete shaderObject->second;
             mShaderMap.erase(shaderObject);
         }
@@ -183,6 +160,7 @@ void ResourceManager::deleteProgram(GLuint program)
     {
         if (programObject->second->getRefCount() == 0)
         {
+            mProgramShaderHandleAllocator.release(programObject->first);
             delete programObject->second;
             mProgramMap.erase(programObject);
         }
@@ -199,6 +177,7 @@ void ResourceManager::deleteTexture(GLuint texture)
 
     if (textureObject != mTextureMap.end())
     {
+        mTextureHandleAllocator.release(textureObject->first);
         if (textureObject->second) textureObject->second->release();
         mTextureMap.erase(textureObject);
     }
@@ -210,6 +189,7 @@ void ResourceManager::deleteRenderbuffer(GLuint renderbuffer)
 
     if (renderbufferObject != mRenderbufferMap.end())
     {
+        mRenderbufferHandleAllocator.release(renderbufferObject->first);
         if (renderbufferObject->second) renderbufferObject->second->release();
         mRenderbufferMap.erase(renderbufferObject);
     }

src/libGLESv2/ResourceManager.h

@@ -16,6 +16,7 @@
 #include <hash_map>
 
 #include "common/angleutils.h"
+#include "libGLESv2/HandleAllocator.h"
 
 namespace gl
 {
@@ -73,18 +74,22 @@ class ResourceManager
 
     typedef stdext::hash_map<GLuint, Buffer*> BufferMap;
     BufferMap mBufferMap;
+    HandleAllocator mBufferHandleAllocator;
 
     typedef stdext::hash_map<GLuint, Shader*> ShaderMap;
     ShaderMap mShaderMap;
 
     typedef stdext::hash_map<GLuint, Program*> ProgramMap;
     ProgramMap mProgramMap;
+    HandleAllocator mProgramShaderHandleAllocator;
 
     typedef stdext::hash_map<GLuint, Texture*> TextureMap;
     TextureMap mTextureMap;
+    HandleAllocator mTextureHandleAllocator;
 
     typedef stdext::hash_map<GLuint, Renderbuffer*> RenderbufferMap;
     RenderbufferMap mRenderbufferMap;
+    HandleAllocator mRenderbufferHandleAllocator;
 };
 
 }