Implement resource management for GL_EXT_memory_object

src/libANGLE/Context.cpp

@@ -26,6 +26,7 @@
 #include "libANGLE/Fence.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/MemoryObject.h"
 #include "libANGLE/Path.h"
 #include "libANGLE/Program.h"
 #include "libANGLE/ProgramPipeline.h"
@@ -727,6 +728,11 @@ GLuint Context::createShaderProgramv(ShaderType type, GLsizei count, const GLcha
     return 0u;
 }
 
+GLuint Context::createMemoryObject()
+{
+    return mState.mMemoryObjectManager->createMemoryObject(mImplementation.get());
+}
+
 void Context::deleteBuffer(GLuint bufferName)
 {
     Buffer *buffer = mState.mBufferManager->getBuffer(bufferName);
@@ -787,6 +793,11 @@ void Context::deleteProgramPipeline(GLuint pipeline)
     mState.mProgramPipelineManager->deleteObject(this, pipeline);
 }
 
+void Context::deleteMemoryObject(GLuint memoryObject)
+{
+    mState.mMemoryObjectManager->deleteMemoryObject(this, memoryObject);
+}
+
 void Context::deletePaths(GLuint first, GLsizei range)
 {
     mState.mPathManager->deletePaths(first, range);
@@ -5682,6 +5693,11 @@ void Context::getProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
     UNIMPLEMENTED();
 }
 
+MemoryObject *Context::getMemoryObject(GLuint handle) const
+{
+    return mState.mMemoryObjectManager->getMemoryObject(handle);
+}
+
 void Context::getProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, GLchar *infolog)
 {
     Program *programObject = getProgramResolveLink(program);
@@ -7099,18 +7115,28 @@ GLboolean Context::testFenceNV(GLuint fence)
 
 void Context::deleteMemoryObjects(GLsizei n, const GLuint *memoryObjects)
 {
-    UNIMPLEMENTED();
+    for (int i = 0; i < n; i++)
+    {
+        deleteMemoryObject(memoryObjects[i]);
+    }
 }
 
 GLboolean Context::isMemoryObject(GLuint memoryObject)
 {
-    UNIMPLEMENTED();
-    return GL_FALSE;
+    if (memoryObject == 0)
+    {
+        return GL_FALSE;
+    }
+
+    return (getMemoryObject(memoryObject) ? GL_TRUE : GL_FALSE);
 }
 
 void Context::createMemoryObjects(GLsizei n, GLuint *memoryObjects)
 {
-    UNIMPLEMENTED();
+    for (int i = 0; i < n; i++)
+    {
+        memoryObjects[i] = createMemoryObject();
+    }
 }
 
 void Context::memoryObjectParameteriv(GLuint memoryObject, GLenum pname, const GLint *params)

src/libANGLE/Context.h

@@ -53,6 +53,7 @@ class FenceNV;
 class Framebuffer;
 class GLES1Renderer;
 class MemoryProgramCache;
+class MemoryObject;
 class Program;
 class ProgramPipeline;
 class Query;
@@ -312,6 +313,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl
     GLuint genPaths(GLsizei range);
     GLuint createProgramPipeline();
     GLuint createShaderProgramv(ShaderType type, GLsizei count, const GLchar *const *strings);
+    GLuint createMemoryObject();
 
     void deleteBuffer(GLuint buffer);
     void deleteShader(GLuint shader);
@@ -320,6 +322,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl
     void deleteRenderbuffer(GLuint renderbuffer);
     void deletePaths(GLuint first, GLsizei range);
     void deleteProgramPipeline(GLuint pipeline);
+    void deleteMemoryObject(GLuint memoryObject);
 
     // CHROMIUM_path_rendering
     bool isPath(GLuint path) const;
@@ -649,6 +652,7 @@ class Context final : public egl::LabeledObject, angle::NonCopyable, public angl
     Query *getQuery(GLuint handle) const;
     TransformFeedback *getTransformFeedback(GLuint handle) const;
     ProgramPipeline *getProgramPipeline(GLuint handle) const;
+    MemoryObject *getMemoryObject(GLuint handle) const;
 
     void objectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
     void objectPtrLabel(const void *ptr, GLsizei length, const GLchar *label);

src/libANGLE/MemoryObject.cpp

+//
+// Copyright 2019 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.
+//
+// MemoryObject.h: Implements the gl::MemoryObject class [EXT_external_objects]
+
+#include "libANGLE/MemoryObject.h"
+
+#include "common/angleutils.h"
+#include "libANGLE/renderer/GLImplFactory.h"
+#include "libANGLE/renderer/MemoryObjectImpl.h"
+
+namespace gl
+{
+
+MemoryObject::MemoryObject(rx::GLImplFactory *factory, GLuint id)
+    : RefCountObject(id), mImplementation(factory->createMemoryObject())
+{}
+
+MemoryObject::~MemoryObject()
+{
+}
+
+void MemoryObject::onDestroy(const Context *context)
+{
+    mImplementation->onDestroy(context);
+}
+
+}  // namespace gl

src/libANGLE/MemoryObject.h

+//
+// Copyright 2019 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.
+//
+// MemoryObject.h: Defines the gl::MemoryObject class [EXT_external_objects]
+
+#ifndef LIBANGLE_MEMORYOBJECT_H_
+#define LIBANGLE_MEMORYOBJECT_H_
+
+#include "angle_gl.h"
+#include "common/angleutils.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/RefCountObject.h"
+
+namespace rx
+{
+class GLImplFactory;
+class MemoryObjectImpl;
+}  // namespace rx
+
+namespace gl
+{
+
+class MemoryObject final : public RefCountObject
+{
+  public:
+    MemoryObject(rx::GLImplFactory *factory, GLuint id);
+    ~MemoryObject() override;
+
+    void onDestroy(const Context *context) override;
+
+  private:
+    std::unique_ptr<rx::MemoryObjectImpl> mImplementation;
+};
+
+}  // namespace gl
+
+#endif  // LIBANGLE_MEMORYOBJECT_H_

src/libANGLE/ResourceManager.cpp

@@ -12,6 +12,7 @@
 #include "libANGLE/Buffer.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Fence.h"
+#include "libANGLE/MemoryObject.h"
 #include "libANGLE/Path.h"
 #include "libANGLE/Program.h"
 #include "libANGLE/ProgramPipeline.h"
@@ -476,4 +477,51 @@ ProgramPipeline *ProgramPipelineManager::getProgramPipeline(GLuint handle) const
     return mObjectMap.query(handle);
 }
 
+// MemoryObjectManager Implementation.
+
+MemoryObjectManager::MemoryObjectManager() {}
+
+MemoryObjectManager::~MemoryObjectManager()
+{
+    ASSERT(mMemoryObjects.empty());
+}
+
+void MemoryObjectManager::reset(const Context *context)
+{
+    while (!mMemoryObjects.empty())
+    {
+        deleteMemoryObject(context, mMemoryObjects.begin()->first);
+    }
+    mMemoryObjects.clear();
+}
+
+GLuint MemoryObjectManager::createMemoryObject(rx::GLImplFactory *factory)
+{
+    GLuint handle = mHandleAllocator.allocate();
+    mMemoryObjects.assign(handle, new MemoryObject(factory, handle));
+    return handle;
+}
+
+void MemoryObjectManager::deleteMemoryObject(const Context *context, GLuint handle)
+{
+    MemoryObject *memoryObject = nullptr;
+    if (!mMemoryObjects.erase(handle, &memoryObject))
+    {
+        return;
+    }
+
+    // Requires an explicit this-> because of C++ template rules.
+    this->mHandleAllocator.release(handle);
+
+    if (memoryObject)
+    {
+        memoryObject->release(context);
+    }
+}
+
+MemoryObject *MemoryObjectManager::getMemoryObject(GLuint handle) const
+{
+    return mMemoryObjects.query(handle);
+}
+
 }  // namespace gl

src/libANGLE/ResourceManager.h

@@ -30,6 +30,7 @@ class Context;
 class Sync;
 class Framebuffer;
 struct Limitations;
+class MemoryObject;
 class Path;
 class Program;
 class ProgramPipeline;
@@ -304,6 +305,24 @@ class ProgramPipelineManager
     ~ProgramPipelineManager() override {}
 };
 
+class MemoryObjectManager : public ResourceManagerBase<HandleAllocator>
+{
+  public:
+    MemoryObjectManager();
+
+    GLuint createMemoryObject(rx::GLImplFactory *factory);
+    void deleteMemoryObject(const Context *context, GLuint handle);
+    MemoryObject *getMemoryObject(GLuint handle) const;
+
+  protected:
+    ~MemoryObjectManager() override;
+
+  private:
+    void reset(const Context *context) override;
+
+    ResourceMap<MemoryObject> mMemoryObjects;
+};
+
 }  // namespace gl
 
 #endif  // LIBANGLE_RESOURCEMANAGER_H_

src/libANGLE/State.cpp

@@ -256,6 +256,8 @@ State::State(ContextID contextIn,
       mPathManager(AllocateOrGetSharedResourceManager(shareContextState, &State::mPathManager)),
       mFramebufferManager(new FramebufferManager()),
       mProgramPipelineManager(new ProgramPipelineManager()),
+      mMemoryObjectManager(
+          AllocateOrGetSharedResourceManager(shareContextState, &State::mMemoryObjectManager)),
       mMaxDrawBuffers(0),
       mMaxCombinedTextureImageUnits(0),
       mDepthClearValue(0),

src/libANGLE/State.h

@@ -34,6 +34,7 @@ class BufferManager;
 struct Caps;
 class Context;
 class FramebufferManager;
+class MemoryObjectManager;
 class PathManager;
 class ProgramPipelineManager;
 class Query;
@@ -713,6 +714,7 @@ class State : angle::NonCopyable
     PathManager *mPathManager;
     FramebufferManager *mFramebufferManager;
     ProgramPipelineManager *mProgramPipelineManager;
+    MemoryObjectManager *mMemoryObjectManager;
 
     // Cached values from Context's caps
     GLuint mMaxDrawBuffers;

src/libANGLE/renderer/GLImplFactory.h

@@ -35,6 +35,7 @@ class ContextImpl;
 class FenceNVImpl;
 class SyncImpl;
 class FramebufferImpl;
+class MemoryObjectImpl;
 class PathImpl;
 class ProgramImpl;
 class ProgramPipelineImpl;
@@ -88,6 +89,9 @@ class GLImplFactory : angle::NonCopyable
     virtual ProgramPipelineImpl *createProgramPipeline(const gl::ProgramPipelineState &data) = 0;
 
     virtual std::vector<PathImpl *> createPaths(GLsizei range) = 0;
+
+    // Memory object creation
+    virtual MemoryObjectImpl *createMemoryObject() = 0;
 };
 
 }  // namespace rx

src/libANGLE/renderer/MemoryObjectImpl.h

+//
+// Copyright 2019 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.
+//
+// MemoryObjectImpl.h: Implements the rx::MemoryObjectImpl class [EXT_external_objects]
+
+#ifndef LIBANGLE_RENDERER_MEMORYOBJECTIMPL_H_
+#define LIBANGLE_RENDERER_MEMORYOBJECTIMPL_H_
+
+#include "angle_gl.h"
+#include "common/angleutils.h"
+#include "libANGLE/Error.h"
+
+namespace gl
+{
+class Context;
+class MemoryObject;
+}  // namespace gl
+
+namespace rx
+{
+
+class MemoryObjectImpl : angle::NonCopyable
+{
+  public:
+    virtual ~MemoryObjectImpl() {}
+
+    virtual void onDestroy(const gl::Context *context) = 0;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_MEMORYOBJECTIMPL_H_

src/libANGLE/renderer/d3d/d3d11/Context11.cpp

@@ -231,6 +231,12 @@ std::vector<PathImpl *> Context11::createPaths(GLsizei)
     return std::vector<PathImpl *>();
 }
 
+MemoryObjectImpl *Context11::createMemoryObject()
+{
+    UNREACHABLE();
+    return nullptr;
+}
+
 angle::Result Context11::flush(const gl::Context *context)
 {
     return mRenderer->flush(this);

src/libANGLE/renderer/d3d/d3d11/Context11.h

@@ -65,6 +65,9 @@ class Context11 : public ContextD3D, public MultisampleTextureInitializer
     // Path object creation.
     std::vector<PathImpl *> createPaths(GLsizei) override;
 
+    // Memory object creation.
+    MemoryObjectImpl *createMemoryObject() override;
+
     // Flush and finish.
     angle::Result flush(const gl::Context *context) override;
     angle::Result finish(const gl::Context *context) override;

src/libANGLE/renderer/d3d/d3d9/Context9.cpp

@@ -133,6 +133,12 @@ std::vector<PathImpl *> Context9::createPaths(GLsizei)
     return std::vector<PathImpl *>();
 }
 
+MemoryObjectImpl *Context9::createMemoryObject()
+{
+    UNREACHABLE();
+    return nullptr;
+}
+
 angle::Result Context9::flush(const gl::Context *context)
 {
     return mRenderer->flush(context);

src/libANGLE/renderer/d3d/d3d9/Context9.h

@@ -64,6 +64,9 @@ class Context9 : public ContextD3D
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei) override;
 
+    // Memory object creation.
+    MemoryObjectImpl *createMemoryObject() override;
+
     // Flush and finish.
     angle::Result flush(const gl::Context *context) override;
     angle::Result finish(const gl::Context *context) override;

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -168,6 +168,12 @@ std::vector<PathImpl *> ContextGL::createPaths(GLsizei range)
     return ret;
 }
 
+MemoryObjectImpl *ContextGL::createMemoryObject()
+{
+    UNREACHABLE();
+    return nullptr;
+}
+
 angle::Result ContextGL::flush(const gl::Context *context)
 {
     return mRenderer->flush();

src/libANGLE/renderer/gl/ContextGL.h

@@ -75,6 +75,9 @@ class ContextGL : public ContextImpl
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei range) override;
 
+    // Memory object creation.
+    MemoryObjectImpl *createMemoryObject() override;
+
     // Flush and finish.
     angle::Result flush(const gl::Context *context) override;
     angle::Result finish(const gl::Context *context) override;

src/libANGLE/renderer/null/ContextNULL.cpp

@@ -392,6 +392,12 @@ std::vector<PathImpl *> ContextNULL::createPaths(GLsizei range)
     return result;
 }
 
+MemoryObjectImpl *ContextNULL::createMemoryObject()
+{
+    UNREACHABLE();
+    return nullptr;
+}
+
 angle::Result ContextNULL::dispatchCompute(const gl::Context *context,
                                            GLuint numGroupsX,
                                            GLuint numGroupsY,

src/libANGLE/renderer/null/ContextNULL.h

@@ -198,6 +198,9 @@ class ContextNULL : public ContextImpl
 
     std::vector<PathImpl *> createPaths(GLsizei range) override;
 
+    // Memory object creation.
+    MemoryObjectImpl *createMemoryObject() override;
+
     angle::Result dispatchCompute(const gl::Context *context,
                                   GLuint numGroupsX,
                                   GLuint numGroupsY,

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -1112,6 +1112,12 @@ std::vector<PathImpl *> ContextVk::createPaths(GLsizei)
     return std::vector<PathImpl *>();
 }
 
+MemoryObjectImpl *ContextVk::createMemoryObject()
+{
+    UNIMPLEMENTED();
+    return nullptr;
+}
+
 void ContextVk::invalidateCurrentTextures()
 {
     ASSERT(mProgram);

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -155,6 +155,9 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::CommandBuff
     // Path object creation
     std::vector<PathImpl *> createPaths(GLsizei) override;
 
+    // Memory object creation.
+    MemoryObjectImpl *createMemoryObject() override;
+
     angle::Result dispatchCompute(const gl::Context *context,
                                   GLuint numGroupsX,
                                   GLuint numGroupsY,

src/libANGLE/validationES2.cpp

@@ -3057,8 +3057,7 @@ bool ValidateCreateMemoryObjectsEXT(Context *context, GLsizei n, GLuint *memoryO
         return false;
     }
 
-    UNIMPLEMENTED();
-    return false;
+    return ValidateGenOrDelete(context, n);
 }
 
 bool ValidateDeleteMemoryObjectsEXT(Context *context, GLsizei n, const GLuint *memoryObjects)
@@ -3069,8 +3068,7 @@ bool ValidateDeleteMemoryObjectsEXT(Context *context, GLsizei n, const GLuint *m
         return false;
     }
 
-    UNIMPLEMENTED();
-    return false;
+    return ValidateGenOrDelete(context, n);
 }
 
 bool ValidateGetMemoryObjectParameterivEXT(Context *context,
@@ -3120,8 +3118,7 @@ bool ValidateIsMemoryObjectEXT(Context *context, GLuint memoryObject)
         return false;
     }
 
-    UNIMPLEMENTED();
-    return false;
+    return true;
 }
 
 bool ValidateMemoryObjectParameterivEXT(Context *context,

src/libGLESv2.gni

@@ -213,6 +213,8 @@ libangle_sources = [
   "src/libANGLE/IndexRangeCache.h",
   "src/libANGLE/LoggingAnnotator.cpp",
   "src/libANGLE/LoggingAnnotator.h",
+  "src/libANGLE/MemoryObject.cpp",
+  "src/libANGLE/MemoryObject.h",
   "src/libANGLE/MemoryProgramCache.cpp",
   "src/libANGLE/MemoryProgramCache.h",
   "src/libANGLE/Observer.cpp",
@@ -298,6 +300,7 @@ libangle_sources = [
   "src/libANGLE/renderer/FramebufferImpl.h",
   "src/libANGLE/renderer/GLImplFactory.h",
   "src/libANGLE/renderer/ImageImpl.h",
+  "src/libANGLE/renderer/MemoryObjectImpl.h",
   "src/libANGLE/renderer/PathImpl.h",
   "src/libANGLE/renderer/ProgramImpl.h",
   "src/libANGLE/renderer/ProgramPipelineImpl.h",

src/tests/angle_unittests_utils.h

@@ -88,6 +88,7 @@ class MockGLFactory : public GLImplFactory
     MOCK_METHOD1(createProgram, ProgramImpl *(const gl::ProgramState &));
     MOCK_METHOD1(createProgramPipeline, ProgramPipelineImpl *(const gl::ProgramPipelineState &));
     MOCK_METHOD1(createFramebuffer, FramebufferImpl *(const gl::FramebufferState &));
+    MOCK_METHOD0(createMemoryObject, MemoryObjectImpl *());
     MOCK_METHOD1(createTexture, TextureImpl *(const gl::TextureState &));
     MOCK_METHOD1(createRenderbuffer, RenderbufferImpl *(const gl::RenderbufferState &));
     MOCK_METHOD1(createBuffer, BufferImpl *(const gl::BufferState &));