Only use direct buffers for static data in D3D11.

src/libGLESv2/renderer/d3d/d3d11/Buffer11.cpp

@@ -597,6 +597,14 @@ Buffer11::PackStorage11 *Buffer11::getPackStorage()
     return static_cast<PackStorage11*>(packStorage);
 }
 
+bool Buffer11::supportsDirectBinding() const
+{
+    // Do not support direct buffers for dynamic data. The streaming buffer
+    // offers better performance for data which changes every frame.
+    // Check for absence of static buffer interfaces to detect dynamic data.
+    return (mStaticVertexBuffer && mStaticIndexBuffer);
+}
+
 Buffer11::BufferStorage11::BufferStorage11(Renderer11 *renderer, BufferUsage usage)
     : mRenderer(renderer),
       mUsage(usage),

src/libGLESv2/renderer/d3d/d3d11/Buffer11.h

@@ -59,7 +59,7 @@ class Buffer11 : public BufferD3D
 
     // BufferD3D implementation
     virtual size_t getSize() const { return mSize; }
-    virtual bool supportsDirectBinding() const { return true; }
+    virtual bool supportsDirectBinding() const;
     virtual Renderer* getRenderer();
 
     // BufferImpl implementation

tests/perf_tests/BufferSubData.cpp

@@ -158,7 +158,7 @@ std::string BufferSubDataParams::name() const
 
     strstr << vertexComponentCount;
 
-    strstr << " - " << updateSize << "b updates - ";
+    strstr << " - " << updateSize << "b updates (per " << updatesEveryNFrames << ") - ";
     strstr << (bufferSize >> 10) << "k buffer - ";
     strstr << iterations << " updates";
 
@@ -167,6 +167,10 @@ std::string BufferSubDataParams::name() const
 
 BufferSubDataBenchmark::BufferSubDataBenchmark(const BufferSubDataParams &params)
     : SimpleBenchmark(params.name(), 1280, 720, 2, params.requestedRenderer),
+      mProgram(0),
+      mBuffer(0),
+      mUpdateData(NULL),
+      mNumTris(0),
       mParams(params)
 {
     mDrawIterations = mParams.iterations;
@@ -208,15 +212,22 @@ bool BufferSubDataBenchmark::initializeBenchmark()
 
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 
+
+    std::vector<uint8_t> zeroData(mParams.bufferSize);
+    memset(zeroData.data(), 0, zeroData.size());
+
     glGenBuffers(1, &mBuffer);
     glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
-    glBufferData(GL_ARRAY_BUFFER, mParams.bufferSize, 0, GL_DYNAMIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, mParams.bufferSize, zeroData.data(), GL_DYNAMIC_DRAW);
 
     glVertexAttribPointer(0, mParams.vertexComponentCount, mParams.vertexType,
                           mParams.vertexNormalized, 0, 0);
     glEnableVertexAttribArray(0);
 
-    mUpdateData = new uint8_t[mParams.updateSize];
+    if (mParams.updateSize > 0)
+    {
+        mUpdateData = new uint8_t[mParams.updateSize];
+    }
 
     std::vector<uint8_t> data;
     GLsizei triDataSize = GetVertexData(mParams.vertexType,
@@ -230,6 +241,12 @@ bool BufferSubDataBenchmark::initializeBenchmark()
         offset += triDataSize;
     }
 
+    if (mParams.updateSize == 0)
+    {
+        mNumTris = 1;
+        glBufferSubData(GL_ARRAY_BUFFER, 0, data.size(), data.data());
+    }
+
     // Set the viewport
     glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
 
@@ -271,7 +288,11 @@ void BufferSubDataBenchmark::drawBenchmark()
 {
     for (unsigned int it = 0; it < mParams.iterations; it++)
     {
-        glBufferSubData(GL_ARRAY_BUFFER, 0, mParams.updateSize, mUpdateData);
+        if (mParams.updateSize > 0 && ((mNumFrames % mParams.updatesEveryNFrames) == 0))
+        {
+            glBufferSubData(GL_ARRAY_BUFFER, 0, mParams.updateSize, mUpdateData);
+        }
+
         glDrawArrays(GL_TRIANGLES, 0, 3 * mNumTris);
     }
 }

tests/perf_tests/BufferSubData.h

@@ -20,6 +20,7 @@ struct BufferSubDataParams : public BenchmarkParams
     GLsizeiptr updateSize;
     GLsizeiptr bufferSize;
     unsigned int iterations;
+    unsigned int updatesEveryNFrames;
 
     virtual std::string name() const;
 };

tests/perf_tests/SimpleBenchmark.h

@@ -47,6 +47,7 @@ class SimpleBenchmark
   protected:
     unsigned int mDrawIterations;
     double mRunTimeSeconds;
+    int mNumFrames;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(SimpleBenchmark);
@@ -57,7 +58,6 @@ class SimpleBenchmark
     void step(float dt, double totalTime);
     void draw();
 
-    int mNumFrames;
     std::string mName;
     bool mRunning;
 

tests/perf_tests/SimpleBenchmarks.cpp

@@ -14,11 +14,12 @@ EGLint platforms[] =
 };
 
 GLenum vertexTypes[] = { GL_FLOAT };
-GLint componentCounts[] = { 2, 3, 4 };
+GLint componentCounts[] = { 4 };
 GLboolean vertexNorms[] = { GL_FALSE };
-GLsizeiptr updateSizes[] = { 300 };
+GLsizeiptr updateSizes[] = { 0, 300 };
 GLsizeiptr bufferSizes[] = { 1024 * 1024 };
 unsigned int iterationCounts[] = { 10 };
+unsigned int updatesEveryNFrames[] = { 1, 4 };
 
 int main(int argc, char **argv)
 {
@@ -44,16 +45,32 @@ int main(int argc, char **argv)
                         {
                             for (size_t itIt = 0; itIt < ArraySize(iterationCounts); itIt++)
                             {
-                                BufferSubDataParams params;
-                                params.requestedRenderer = platforms[platIt];
-                                params.vertexType = vertexTypes[typeIt];
-                                params.vertexComponentCount = componentCounts[compIt];
-                                params.vertexNormalized = vertexNorms[normIt];
-                                params.updateSize = updateSizes[updateIt];
-                                params.bufferSize = bufferSizes[bufszIt];
-                                params.iterations = iterationCounts[itIt];
+                                for (size_t nfrIt = 0; nfrIt < ArraySize(updatesEveryNFrames); nfrIt++)
+                                {
+                                    BufferSubDataParams params;
+                                    params.requestedRenderer = platforms[platIt];
+                                    params.vertexType = vertexTypes[typeIt];
+                                    params.vertexComponentCount = componentCounts[compIt];
+                                    params.vertexNormalized = vertexNorms[normIt];
+                                    params.updateSize = updateSizes[updateIt];
+                                    params.bufferSize = bufferSizes[bufszIt];
+                                    params.iterations = iterationCounts[itIt];
+                                    params.updatesEveryNFrames = updatesEveryNFrames[nfrIt];
 
-                                benchmarks.push_back(params);
+                                    if (updateSizes[updateIt] == 0)
+                                    {
+                                        if (nfrIt > 0)
+                                        {
+                                            continue;
+                                        }
+                                        else
+                                        {
+                                            params.updatesEveryNFrames = 1;
+                                        }
+                                    }
+
+                                    benchmarks.push_back(params);
+                                }
                             }
                         }
                     }