Revert "D3D11: Reduce overhead of clearing unused textures."

src/common/mathutil.h

@@ -524,17 +524,6 @@ struct Range
             return start < other.end;
         }
     }
-
-    void extend(T value)
-    {
-        start = value > start ? value : start;
-        end = value < end ? value : end;
-    }
-
-    bool empty() const
-    {
-        return end <= start;
-    }
 };
 
 typedef Range<int> RangeI;

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -444,7 +444,14 @@ gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shade
     // Set all the remaining textures to NULL
     size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? data.caps->maxTextureImageUnits
                                                             : data.caps->maxVertexTextureImageUnits;
-    clearTextures(shaderType, samplerRange, samplerCount);
+    for (size_t samplerIndex = samplerRange; samplerIndex < samplerCount; samplerIndex++)
+    {
+        gl::Error error = setTexture(shaderType, samplerIndex, NULL);
+        if (error.isError())
+        {
+            return error;
+        }
+    }
 
     return gl::Error(GL_NO_ERROR);
 }

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -190,9 +190,6 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     void pushGroupMarker(GLsizei length, const char *marker) override;
     void popGroupMarker() override;
 
-    // In D3D11, faster than calling setTexture a jillion times
-    virtual gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) = 0;
-
   protected:
     virtual gl::Error drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool usesPointSize) = 0;
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,

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

@@ -188,45 +188,6 @@ ANGLEFeatureLevel GetANGLEFeatureLevel(D3D_FEATURE_LEVEL d3dFeatureLevel)
 
 }
 
-void Renderer11::SRVCache::update(size_t resourceIndex, ID3D11ShaderResourceView *srv)
-{
-    ASSERT(resourceIndex < mCurrentSRVs.size());
-    SRVRecord *record = &mCurrentSRVs[resourceIndex];
-
-    record->srv = reinterpret_cast<uintptr_t>(srv);
-    if (srv)
-    {
-        record->resource = reinterpret_cast<uintptr_t>(GetViewResource(srv));
-        srv->GetDesc(&record->desc);
-        mHighestUsedSRV = std::max(resourceIndex + 1, mHighestUsedSRV);
-    }
-    else
-    {
-        record->resource = 0;
-
-        if (resourceIndex + 1 == mHighestUsedSRV)
-        {
-            do
-            {
-                --mHighestUsedSRV;
-            }
-            while (mHighestUsedSRV > 0 &&
-                   mCurrentSRVs[mHighestUsedSRV].srv == 0);
-        }
-    }
-}
-
-void Renderer11::SRVCache::clear()
-{
-    if (mCurrentSRVs.empty())
-    {
-        return;
-    }
-
-    memset(&mCurrentSRVs[0], 0, sizeof(SRVRecord) * mCurrentSRVs.size());
-    mHighestUsedSRV = 0;
-}
-
 Renderer11::Renderer11(egl::Display *display)
     : RendererD3D(display),
       mStateCache(this),
@@ -625,8 +586,8 @@ void Renderer11::initializeDevice()
     mForceSetPixelSamplerStates.resize(rendererCaps.maxTextureImageUnits);
     mCurPixelSamplerStates.resize(rendererCaps.maxTextureImageUnits);
 
-    mCurVertexSRVs.initialize(rendererCaps.maxVertexTextureImageUnits);
-    mCurPixelSRVs.initialize(rendererCaps.maxTextureImageUnits);
+    mCurVertexSRVs.resize(rendererCaps.maxVertexTextureImageUnits);
+    mCurPixelSRVs.resize(rendererCaps.maxTextureImageUnits);
 
     markAllStateDirty();
 
@@ -644,9 +605,6 @@ void Renderer11::initializeDevice()
         angleFeatureLevel = ANGLE_FEATURE_LEVEL_11_1;
     }
 
-    // Initialize cached NULL SRV block
-    mNullSRVs.resize(getRendererCaps().maxTextureImageUnits, nullptr);
-
     ANGLE_HISTOGRAM_ENUMERATION("GPU.ANGLE.D3D11FeatureLevel",
                                 angleFeatureLevel,
                                 NUM_ANGLE_FEATURE_LEVELS);
@@ -2226,8 +2184,8 @@ void Renderer11::markAllStateDirty()
     // We reset the current SRV data because it might not be in sync with D3D's state
     // anymore. For example when a currently used SRV is used as an RTV, D3D silently
     // remove it from its state.
-    mCurVertexSRVs.clear();
-    mCurPixelSRVs.clear();
+    memset(mCurVertexSRVs.data(), 0, sizeof(SRVRecord) * mCurVertexSRVs.size());
+    memset(mCurPixelSRVs.data(), 0, sizeof(SRVRecord) * mCurPixelSRVs.size());
 
     ASSERT(mForceSetVertexSamplerStates.size() == mCurVertexSRVs.size());
     for (size_t vsamplerId = 0; vsamplerId < mForceSetVertexSamplerStates.size(); ++vsamplerId)
@@ -3717,7 +3675,7 @@ void Renderer11::setShaderResource(gl::SamplerType shaderType, UINT resourceSlot
     auto &currentSRVs = (shaderType == gl::SAMPLER_VERTEX ? mCurVertexSRVs : mCurPixelSRVs);
 
     ASSERT(static_cast<size_t>(resourceSlot) < currentSRVs.size());
-    const SRVRecord &record = currentSRVs[resourceSlot];
+    auto &record = currentSRVs[resourceSlot];
 
     if (record.srv != reinterpret_cast<uintptr_t>(srv))
     {
@@ -3730,7 +3688,16 @@ void Renderer11::setShaderResource(gl::SamplerType shaderType, UINT resourceSlot
             mDeviceContext->PSSetShaderResources(resourceSlot, 1, &srv);
         }
 
-        currentSRVs.update(resourceSlot, srv);
+        record.srv = reinterpret_cast<uintptr_t>(srv);
+        if (srv)
+        {
+            record.resource = reinterpret_cast<uintptr_t>(GetViewResource(srv));
+            srv->GetDesc(&record.desc);
+        }
+        else
+        {
+            record.resource = 0;
+        }
     }
 }
 
@@ -3739,38 +3706,4 @@ void Renderer11::createAnnotator()
     mAnnotator = new DebugAnnotator11();
 }
 
-gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
-{
-    if (rangeStart == rangeEnd)
-    {
-        return;
-    }
-
-    auto &currentSRVs = (samplerType == gl::SAMPLER_VERTEX ? mCurVertexSRVs : mCurPixelSRVs);
-
-    gl::Range<size_t> clearRange(rangeStart, rangeStart);
-    clearRange.extend(std::min(rangeEnd, currentSRVs.highestUsed()));
-
-    if (clearRange.empty())
-    {
-        return;
-    }
-
-    if (samplerType == gl::SAMPLER_VERTEX)
-    {
-        mDeviceContext->VSSetShaderResources(rangeStart, rangeEnd - rangeStart, &mNullSRVs[0]);
-    }
-    else
-    {
-        mDeviceContext->PSSetShaderResources(rangeStart, rangeEnd - rangeStart, &mNullSRVs[0]);
-    }
-
-    for (size_t samplerIndex = rangeStart; samplerIndex < rangeEnd; ++samplerIndex)
-    {
-        currentSRVs.update(samplerIndex, nullptr);
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
-
 }

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

@@ -266,7 +266,6 @@ class Renderer11 : public RendererD3D
 
   protected:
     void createAnnotator() override;
-    gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
 
   private:
     void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const override;
@@ -321,41 +320,8 @@ class Renderer11 : public RendererD3D
         uintptr_t resource;
         D3D11_SHADER_RESOURCE_VIEW_DESC desc;
     };
-
-    // A cache of current SRVs that also tracks the highest 'used' (non-NULL) SRV
-    // We might want to investigate a more robust approach that is also fast when there's
-    // a large gap between used SRVs (e.g. if SRV 0 and 7 are non-NULL, this approach will
-    // waste time on SRVs 1-6.)
-    class SRVCache : angle::NonCopyable
-    {
-      public:
-        SRVCache()
-            : mHighestUsedSRV(0)
-        {
-        }
-
-        void initialize(size_t size)
-        {
-            mCurrentSRVs.resize(size);
-        }
-
-        size_t size() const { return mCurrentSRVs.size(); }
-        size_t highestUsed() const { return mHighestUsedSRV; }
-
-        const SRVRecord &operator[](size_t index) const { return mCurrentSRVs[index]; }
-        void clear();
-        void update(size_t resourceIndex, ID3D11ShaderResourceView *srv);
-
-      private:
-        std::vector<SRVRecord> mCurrentSRVs;
-        size_t mHighestUsedSRV;
-    };
-
-    SRVCache mCurVertexSRVs;
-    SRVCache mCurPixelSRVs;
-
-    // A block of NULL pointers, cached so we don't re-allocate every draw call
-    std::vector<ID3D11ShaderResourceView*> mNullSRVs;
+    std::vector<SRVRecord> mCurVertexSRVs;
+    std::vector<SRVRecord> mCurPixelSRVs;
 
     // Currently applied blend state
     bool mForceSetBlendState;

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

@@ -2942,19 +2942,4 @@ void Renderer9::createAnnotator()
     mAnnotator = new DebugAnnotator9();
 }
 
-gl::Error Renderer9::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd)
-{
-    // TODO(jmadill): faster way?
-    for (size_t samplerIndex = rangeStart; samplerIndex < rangeEnd; samplerIndex++)
-    {
-        gl::Error error = setTexture(samplerType, samplerIndex, nullptr);
-        if (error.isError())
-        {
-            return error;
-        }
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
-
 }

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

@@ -235,7 +235,6 @@ class Renderer9 : public RendererD3D
 
   protected:
     void createAnnotator() override;
-    gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
 
   private:
     void generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureCaps, gl::Extensions *outExtensions) const override;