[Impeller] store GLES bindings on render pass w/ offsets instead of per-command. (#56910)

To reduce heap fragmentation from tons of little vectors.

Author: Jonah Williams

impeller/entity/BUILD.gn

@@ -229,8 +229,6 @@ impeller_component("entity_test_helpers") {
   testonly = true
 
   sources = [
-    "contents/test/contents_test_helpers.cc",
-    "contents/test/contents_test_helpers.h",
     "contents/test/recording_render_pass.cc",
     "contents/test/recording_render_pass.h",
   ]

impeller/entity/contents/runtime_effect_contents.cc

@@ -24,6 +24,38 @@
 
 namespace impeller {
 
+namespace {
+constexpr char kPaddingType = 0;
+constexpr char kFloatType = 1;
+}  // namespace
+
+// static
+BufferView RuntimeEffectContents::EmplaceVulkanUniform(
+    const std::shared_ptr<const std::vector<uint8_t>>& input_data,
+    HostBuffer& host_buffer,
+    const RuntimeUniformDescription& uniform) {
+  // TODO(jonahwilliams): rewrite this to emplace directly into
+  // HostBuffer.
+  std::vector<float> uniform_buffer;
+  uniform_buffer.reserve(uniform.struct_layout.size());
+  size_t uniform_byte_index = 0u;
+  for (char byte_type : uniform.struct_layout) {
+    if (byte_type == kPaddingType) {
+      uniform_buffer.push_back(0.f);
+    } else {
+      FML_DCHECK(byte_type == kFloatType);
+      uniform_buffer.push_back(reinterpret_cast<const float*>(
+          input_data->data())[uniform_byte_index++]);
+    }
+  }
+  size_t alignment = std::max(sizeof(float) * uniform_buffer.size(),
+                              DefaultUniformAlignment());
+
+  return host_buffer.Emplace(
+      reinterpret_cast<const void*>(uniform_buffer.data()),
+      sizeof(float) * uniform_buffer.size(), alignment);
+}
+
 void RuntimeEffectContents::SetRuntimeStage(
     std::shared_ptr<RuntimeStage> runtime_stage) {
   runtime_stage_ = std::move(runtime_stage);
@@ -251,30 +283,11 @@ bool RuntimeEffectContents::Render(const ContentContext& renderer,
           uniform_slot.binding = uniform.location;
           uniform_slot.name = uniform.name.c_str();
 
-          // TODO(jonahwilliams): rewrite this to emplace directly into
-          // HostBuffer.
-          std::vector<float> uniform_buffer;
-          uniform_buffer.reserve(uniform.struct_layout.size());
-          size_t uniform_byte_index = 0u;
-          for (const auto& byte_type : uniform.struct_layout) {
-            if (byte_type == 0) {
-              uniform_buffer.push_back(0.f);
-            } else if (byte_type == 1) {
-              uniform_buffer.push_back(reinterpret_cast<float*>(
-                  uniform_data_->data())[uniform_byte_index++]);
-            } else {
-              FML_UNREACHABLE();
-            }
-          }
-          size_t alignment = std::max(sizeof(float) * uniform_buffer.size(),
-                                      DefaultUniformAlignment());
-
-          BufferView buffer_view = renderer.GetTransientsBuffer().Emplace(
-              reinterpret_cast<const void*>(uniform_buffer.data()),
-              sizeof(float) * uniform_buffer.size(), alignment);
-          pass.BindResource(ShaderStage::kFragment,
-                            DescriptorType::kUniformBuffer, uniform_slot,
-                            nullptr, std::move(buffer_view));
+          pass.BindResource(
+              ShaderStage::kFragment, DescriptorType::kUniformBuffer,
+              uniform_slot, nullptr,
+              EmplaceVulkanUniform(uniform_data_,
+                                   renderer.GetTransientsBuffer(), uniform));
         }
       }
     }

impeller/entity/contents/runtime_effect_contents.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "impeller/core/host_buffer.h"
 #include "impeller/core/sampler_descriptor.h"
 #include "impeller/entity/contents/color_source_contents.h"
 #include "impeller/runtime_stage/runtime_stage.h"
@@ -35,6 +36,12 @@ class RuntimeEffectContents final : public ColorSourceContents {
   /// Load the runtime effect and ensure a default PSO is initialized.
   bool BootstrapShader(const ContentContext& renderer) const;
 
+  // Visible for testing
+  static BufferView EmplaceVulkanUniform(
+      const std::shared_ptr<const std::vector<uint8_t>>& input_data,
+      HostBuffer& host_buffer,
+      const RuntimeUniformDescription& uniform);
+
  private:
   bool RegisterShader(const ContentContext& renderer) const;
 

impeller/entity/contents/test/contents_test_helpers.cc

@@ -110,7 +110,6 @@ bool RecordingRenderPass::BindResource(ShaderStage stage,
                                        const ShaderUniformSlot& slot,
                                        const ShaderMetadata* metadata,
                                        BufferView view) {
-  pending_.BindResource(stage, type, slot, metadata, view);
   if (delegate_) {
     return delegate_->BindResource(stage, type, slot, metadata, view);
   }
@@ -124,7 +123,6 @@ bool RecordingRenderPass::BindDynamicResource(
     const ShaderUniformSlot& slot,
     std::unique_ptr<ShaderMetadata> metadata,
     BufferView view) {
-  pending_.BindResource(stage, type, slot, metadata.get(), view);
   if (delegate_) {
     return delegate_->BindDynamicResource(stage, type, slot,
                                           std::move(metadata), view);
@@ -140,7 +138,6 @@ bool RecordingRenderPass::BindDynamicResource(
     std::unique_ptr<ShaderMetadata> metadata,
     std::shared_ptr<const Texture> texture,
     const std::unique_ptr<const Sampler>& sampler) {
-  pending_.BindResource(stage, type, slot, metadata.get(), texture, sampler);
   if (delegate_) {
     return delegate_->BindDynamicResource(
         stage, type, slot, std::move(metadata), texture, sampler);
@@ -155,7 +152,6 @@ bool RecordingRenderPass::BindResource(
     const ShaderMetadata* metadata,
     std::shared_ptr<const Texture> texture,
     const std::unique_ptr<const Sampler>& sampler) {
-  pending_.BindResource(stage, type, slot, metadata, texture, sampler);
   if (delegate_) {
     return delegate_->BindResource(stage, type, slot, metadata, texture,
                                    sampler);

impeller/entity/contents/test/contents_test_helpers.h

@@ -1843,27 +1843,16 @@ TEST_P(EntityTest, RuntimeEffectSetsRightSizeWhenUniformIsStruct) {
   auto uniform_data = std::make_shared<std::vector<uint8_t>>();
   uniform_data->resize(sizeof(FragUniforms));
   memcpy(uniform_data->data(), &frag_uniforms, sizeof(FragUniforms));
-  contents->SetUniformData(uniform_data);
-
-  Entity entity;
-  entity.SetContents(contents);
 
-  auto context = GetContentContext();
-  RenderTarget target = context->GetRenderTargetCache()->CreateOffscreen(
-      *context->GetContext(), {1, 1}, 1u);
+  auto buffer_view = RuntimeEffectContents::EmplaceVulkanUniform(
+      uniform_data, GetContentContext()->GetTransientsBuffer(),
+      runtime_stage->GetUniforms()[0]);
 
-  testing::MockRenderPass pass(GetContext(), target);
-  ASSERT_TRUE(contents->Render(*context, entity, pass));
-  ASSERT_EQ(pass.GetCommands().size(), 1u);
-  const auto& command = pass.GetCommands()[0];
-  ASSERT_EQ(command.fragment_bindings.buffers.size(), 1u);
   // 16 bytes:
   //   8 bytes for iResolution
   //   4 bytes for iTime
   //   4 bytes padding
-  EXPECT_EQ(
-      command.fragment_bindings.buffers[0].view.resource.GetRange().length,
-      16u);
+  EXPECT_EQ(buffer_view.GetRange().length, 16u);
 }
 
 TEST_P(EntityTest, ColorFilterWithForegroundColorAdvancedBlend) {

impeller/entity/contents/test/recording_render_pass.cc

@@ -13,6 +13,7 @@
 #include "impeller/renderer/backend/gles/formats_gles.h"
 #include "impeller/renderer/backend/gles/sampler_gles.h"
 #include "impeller/renderer/backend/gles/texture_gles.h"
+#include "impeller/renderer/command.h"
 
 namespace impeller {
 
@@ -179,27 +180,23 @@ bool BufferBindingsGLES::BindVertexAttributes(const ProcTableGLES& gl,
   return true;
 }
 
-bool BufferBindingsGLES::BindUniformData(const ProcTableGLES& gl,
-                                         const Bindings& vertex_bindings,
-                                         const Bindings& fragment_bindings) {
-  for (const auto& buffer : vertex_bindings.buffers) {
-    if (!BindUniformBuffer(gl, buffer.view)) {
-      return false;
-    }
-  }
-  for (const auto& buffer : fragment_bindings.buffers) {
-    if (!BindUniformBuffer(gl, buffer.view)) {
+bool BufferBindingsGLES::BindUniformData(
+    const ProcTableGLES& gl,
+    const std::vector<TextureAndSampler>& bound_textures,
+    const std::vector<BufferResource>& bound_buffers,
+    Range texture_range,
+    Range buffer_range) {
+  for (auto i = 0u; i < buffer_range.length; i++) {
+    if (!BindUniformBuffer(gl, bound_buffers[buffer_range.offset + i])) {
       return false;
     }
   }
-
   std::optional<size_t> next_unit_index =
-      BindTextures(gl, vertex_bindings, ShaderStage::kVertex);
+      BindTextures(gl, bound_textures, texture_range, ShaderStage::kVertex);
   if (!next_unit_index.has_value()) {
     return false;
   }
-
-  if (!BindTextures(gl, fragment_bindings, ShaderStage::kFragment,
+  if (!BindTextures(gl, bound_textures, texture_range, ShaderStage::kFragment,
                     *next_unit_index)
            .has_value()) {
     return false;
@@ -389,11 +386,16 @@ bool BufferBindingsGLES::BindUniformBuffer(const ProcTableGLES& gl,
 
 std::optional<size_t> BufferBindingsGLES::BindTextures(
     const ProcTableGLES& gl,
-    const Bindings& bindings,
+    const std::vector<TextureAndSampler>& bound_textures,
+    Range texture_range,
     ShaderStage stage,
     size_t unit_start_index) {
   size_t active_index = unit_start_index;
-  for (const auto& data : bindings.sampled_images) {
+  for (auto i = 0u; i < texture_range.length; i++) {
+    const TextureAndSampler& data = bound_textures[texture_range.offset + i];
+    if (data.stage != stage) {
+      continue;
+    }
     const auto& texture_gles = TextureGLES::Cast(*data.texture.resource);
     if (data.texture.GetMetadata() == nullptr) {
       VALIDATION_LOG << "No metadata found for texture binding.";

impeller/entity/entity_unittests.cc

@@ -42,8 +42,10 @@ class BufferBindingsGLES {
                             size_t vertex_offset);
 
   bool BindUniformData(const ProcTableGLES& gl,
-                       const Bindings& vertex_bindings,
-                       const Bindings& fragment_bindings);
+                       const std::vector<TextureAndSampler>& bound_textures,
+                       const std::vector<BufferResource>& bound_buffers,
+                       Range texture_range,
+                       Range buffer_range);
 
   bool UnbindVertexAttributes(const ProcTableGLES& gl);
 
@@ -75,10 +77,12 @@ class BufferBindingsGLES {
 
   bool BindUniformBuffer(const ProcTableGLES& gl, const BufferResource& buffer);
 
-  std::optional<size_t> BindTextures(const ProcTableGLES& gl,
-                                     const Bindings& bindings,
-                                     ShaderStage stage,
-                                     size_t unit_start_index = 0);
+  std::optional<size_t> BindTextures(
+      const ProcTableGLES& gl,
+      const std::vector<TextureAndSampler>& bound_textures,
+      Range texture_range,
+      ShaderStage stage,
+      size_t unit_start_index = 0);
 
   BufferBindingsGLES(const BufferBindingsGLES&) = delete;
 

impeller/renderer/backend/gles/buffer_bindings_gles.cc

@@ -7,7 +7,7 @@
 #include "impeller/renderer/backend/gles/buffer_bindings_gles.h"
 #include "impeller/renderer/backend/gles/device_buffer_gles.h"
 #include "impeller/renderer/backend/gles/test/mock_gles.h"
-#include "impeller/renderer/testing/mocks.h"
+#include "impeller/renderer/command.h"
 
 namespace impeller {
 namespace testing {
@@ -18,7 +18,8 @@ TEST(BufferBindingsGLESTest, BindUniformData) {
   uniform_bindings["SHADERMETADATA.FOOBAR"] = 1;
   bindings.SetUniformBindings(std::move(uniform_bindings));
   std::shared_ptr<MockGLES> mock_gl = MockGLES::Init();
-  Bindings vertex_bindings;
+  std::vector<BufferResource> bound_buffers;
+  std::vector<TextureAndSampler> bound_textures;
 
   ShaderMetadata shader_metadata = {
       .name = "shader_metadata",
@@ -33,14 +34,11 @@ TEST(BufferBindingsGLESTest, BindUniformData) {
   DeviceBufferGLES device_buffer(DeviceBufferDescriptor{.size = sizeof(float)},
                                  reactor, backing_store);
   BufferView buffer_view(&device_buffer, Range(0, sizeof(float)));
-  vertex_bindings.buffers.push_back(BufferAndUniformSlot{
-      .slot =
-          ShaderUniformSlot{
-              .name = "foobar", .ext_res_0 = 0, .set = 0, .binding = 0},
-      .view = BufferResource(&shader_metadata, buffer_view)});
-  Bindings fragment_bindings;
-  EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), vertex_bindings,
-                                       fragment_bindings));
+  bound_buffers.push_back(BufferResource(&shader_metadata, buffer_view));
+
+  EXPECT_TRUE(bindings.BindUniformData(mock_gl->GetProcTable(), bound_textures,
+                                       bound_buffers, Range{0, 0},
+                                       Range{0, 1}));
   std::vector<std::string> captured_calls = mock_gl->GetCapturedCalls();
   EXPECT_TRUE(std::find(captured_calls.begin(), captured_calls.end(),
                         "glUniform1fv") != captured_calls.end());