commit 05b35b210ef3dcdf7e3260d192ce51b602b6f3a7
author Jamie Madill <jmadill@chromium.org> Tue Oct 03 09:01:44 2017 -0400
committer Commit Bot <commit-bot@chromium.org> Tue Oct 03 14:18:13 2017 +0000
tree 8e20656707f31f2fc987e7fac92e5f95b731fe19
parent a60d35672ed9dba63e5141859fcb25d903de65b5

D3D11: Lazy robust resource init.

This patch moves the robust resource init logic to the GL front-end.
Instead of initializing texture resources immediately on creation in
D3D11, it defers the clear until before a draw call in some cases, or
skips the update if we can determine if a texture (or other resource)
has been fully initialized.

Currently lazy init is only implemented for Textures, Renderbuffers,
and Surfaces.

Various places where lazy resource init is triggered:
* Framebuffer operations (Draw, Blit, CopyTexImage, Clear, ReadPixels)
* Texture operations (SubImage, GenerateMipmap, CopyTexImage)

Some efficiency gains remain to be implemented, such as when a
SubImage call fills the entire object. Similarly for Blit, and a few
other operations. In these cases we can skip lazy init as an
optimization. Edge cases with EGLImage are mostly untested.

BUG=angleproject:2107

Change-Id: I2bf3a69b1eae0d4feeb5b17daca23451f1037be8
Reviewed-on: https://chromium-review.googlesource.com/576058
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>

src/libANGLE/Image.cpp

diff --git a/src/libANGLE/Image.cpp b/src/libANGLE/Image.cpp
index 93c9522..5612b9b 100644
--- a/src/libANGLE/Image.cpp
+++ b/src/libANGLE/Image.cpp
@@ -45,7 +45,8 @@
 }
 }  // anonymous namespace
 
-ImageSibling::ImageSibling(GLuint id) : RefCountObject(id), mSourcesOf(), mTargetOf()
+ImageSibling::ImageSibling(GLuint id)
+    : RefCountObject(id), FramebufferAttachmentObject(), mSourcesOf(), mTargetOf()
 {
 }
 
@@ -99,6 +100,23 @@
     mSourcesOf.erase(imageSource);
 }
 
+bool ImageSibling::isEGLImageTarget() const
+{
+    return (mTargetOf.get() != nullptr);
+}
+
+gl::InitState ImageSibling::sourceEGLImageInitState() const
+{
+    ASSERT(isEGLImageTarget());
+    return mTargetOf->sourceInitState();
+}
+
+void ImageSibling::setSourceEGLImageInitState(gl::InitState initState) const
+{
+    ASSERT(isEGLImageTarget());
+    mTargetOf->setInitState(initState);
+}
+
 ImageState::ImageState(EGLenum target, ImageSibling *buffer, const AttributeMap &attribs)
     : imageIndex(GetImageIndex(target, attribs)), source(buffer), targets()
 {
@@ -110,7 +128,8 @@
              const AttributeMap &attribs)
     : RefCountObject(0),
       mState(target, buffer, attribs),
-      mImplementation(factory->createImage(mState, target, attribs))
+      mImplementation(factory->createImage(mState, target, attribs)),
+      mOrphanedAndNeedsInit(false)
 {
     ASSERT(mImplementation != nullptr);
     ASSERT(buffer != nullptr);
@@ -153,6 +172,8 @@
         // If the sibling is the source, it cannot be a target.
         ASSERT(mState.targets.find(sibling) == mState.targets.end());
         mState.source.set(context, nullptr);
+        mOrphanedAndNeedsInit =
+            (sibling->initState(mState.imageIndex) == gl::InitState::MayNeedInit);
     }
     else
     {
@@ -192,4 +213,29 @@
     return mImplementation->initialize();
 }
 
+bool Image::orphaned() const
+{
+    return (mState.source.get() == nullptr);
+}
+
+gl::InitState Image::sourceInitState() const
+{
+    if (orphaned())
+    {
+        return mOrphanedAndNeedsInit ? gl::InitState::MayNeedInit : gl::InitState::Initialized;
+    }
+
+    return mState.source->initState(mState.imageIndex);
+}
+
+void Image::setInitState(gl::InitState initState)
+{
+    if (orphaned())
+    {
+        mOrphanedAndNeedsInit = false;
+    }
+
+    return mState.source->setInitState(mState.imageIndex, initState);
+}
+
 }  // namespace egl