[Impeller] add compute pass API for memory barriers, re-enable for Vulkan.

impeller/entity/geometry/point_field_geometry.cc

@@ -200,6 +200,7 @@ GeometryResult PointFieldGeometry::GetPositionBufferGPU(
 
     using UV = UvComputeShader;
 
+    compute_pass->AddBufferMemoryBarrier();
     compute_pass->SetCommandLabel("UV Geometry");
     compute_pass->SetPipeline(renderer.GetUvComputePipeline());
 
@@ -267,9 +268,7 @@ GeometryVertexType PointFieldGeometry::GetVertexType() const {
 // Compute is disabled for Vulkan because the barriers are incorrect, see
 // also: https://github.com/flutter/flutter/issues/140798 .
 bool PointFieldGeometry::CanUseCompute(const ContentContext& renderer) {
-  return renderer.GetDeviceCapabilities().SupportsCompute() &&
-         renderer.GetContext()->GetBackendType() ==
-             Context::BackendType::kMetal;
+  return renderer.GetDeviceCapabilities().SupportsCompute();
 }
 
 // |Geometry|

impeller/renderer/backend/metal/compute_pass_mtl.h

@@ -66,6 +66,12 @@ class ComputePassMTL final : public ComputePass {
   // |ComputePass|
   bool EncodeCommands() const override;
 
+  // |ComputePass|
+  void AddBufferMemoryBarrier() override;
+
+  // |ComputePass|
+  void AddTextureMemoryBarrier() override;
+
   ComputePassMTL(const ComputePassMTL&) = delete;
 
   ComputePassMTL& operator=(const ComputePassMTL&) = delete;

impeller/renderer/backend/metal/compute_pass_mtl.mm

@@ -32,7 +32,8 @@
   if (!buffer_) {
     return;
   }
-  encoder_ = [buffer_ computeCommandEncoder];
+  encoder_ = [buffer_ computeCommandEncoderWithDispatchType:
+                          MTLDispatchType::MTLDispatchTypeConcurrent];
   if (!encoder_) {
     return;
   }
@@ -67,6 +68,16 @@
       ComputePipelineMTL::Cast(*pipeline).GetMTLComputePipelineState());
 }
 
+// |ComputePass|
+void ComputePassMTL::AddBufferMemoryBarrier() {
+  [encoder_ memoryBarrierWithScope:MTLBarrierScopeBuffers];
+}
+
+// |ComputePass|
+void ComputePassMTL::AddTextureMemoryBarrier() {
+  [encoder_ memoryBarrierWithScope:MTLBarrierScopeTextures];
+}
+
 // |ComputePass|
 bool ComputePassMTL::BindResource(ShaderStage stage,
                                   DescriptorType type,

impeller/renderer/backend/vulkan/compute_pass_vk.cc

@@ -213,8 +213,53 @@ bool ComputePassVK::BindResource(size_t binding,
   return true;
 }
 
+// Note:
+// https://github.com/KhronosGroup/Vulkan-Docs/wiki/Synchronization-Examples
+// Seems to suggest that anything more finely grained than a global memory
+// barrier is likely to be ignored. Confirming this on mobile devices will
+// require some experimentation.
+
+// |ComputePass|
+void ComputePassVK::AddBufferMemoryBarrier() {
+  vk::MemoryBarrier barrier;
+  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
+  barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
+
+  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
+      vk::PipelineStageFlagBits::eComputeShader,
+      vk::PipelineStageFlagBits::eComputeShader, {}, 1, &barrier, 0, {}, 0, {});
+}
+
+// |ComputePass|
+void ComputePassVK::AddTextureMemoryBarrier() {
+  vk::MemoryBarrier barrier;
+  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
+  barrier.dstAccessMask = vk::AccessFlagBits::eShaderRead;
+
+  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
+      vk::PipelineStageFlagBits::eComputeShader,
+      vk::PipelineStageFlagBits::eComputeShader, {}, 1, &barrier, 0, {}, 0, {});
+}
+
 // |ComputePass|
 bool ComputePassVK::EncodeCommands() const {
+  // Since we only use global memory barrier, we don't have to worry about
+  // compute to compute dependencies across cmd buffers. Instead, we pessimize
+  // here and assume that we wrote to a storage image or buffer and that a
+  // render pass will read from it. if there are ever scenarios where we end up
+  // with compute to compute dependencies this should be revisited.
+
+  // This does not currently handle image barriers as we do not use them
+  // for anything.
+  vk::MemoryBarrier barrier;
+  barrier.srcAccessMask = vk::AccessFlagBits::eShaderWrite;
+  barrier.dstAccessMask =
+      vk::AccessFlagBits::eIndexRead | vk::AccessFlagBits::eVertexAttributeRead;
+
+  command_buffer_->GetEncoder()->GetCommandBuffer().pipelineBarrier(
+      vk::PipelineStageFlagBits::eComputeShader,
+      vk::PipelineStageFlagBits::eVertexInput, {}, 1, &barrier, 0, {}, 0, {});
+
   return true;
 }
 

impeller/renderer/backend/vulkan/compute_pass_vk.h

@@ -57,6 +57,12 @@ class ComputePassVK final : public ComputePass {
   void SetPipeline(const std::shared_ptr<Pipeline<ComputePipelineDescriptor>>&
                        pipeline) override;
 
+  // |ComputePass|
+  void AddBufferMemoryBarrier() override;
+
+  // |ComputePass|
+  void AddTextureMemoryBarrier() override;
+
   // |ComputePass|
   fml::Status Compute(const ISize& grid_size) override;
 

impeller/renderer/compute_pass.h

@@ -35,6 +35,19 @@ class ComputePass : public ResourceBinder {
 
   virtual fml::Status Compute(const ISize& grid_size) = 0;
 
+  /// @brief Ensures all previously encoded commands have finished reading or
+  ///        writing to any buffer before subsequent commands will access it.
+  ///
+  ///        This only handles read after write hazards.
+  virtual void AddBufferMemoryBarrier() = 0;
+
+  /// @brief Add a barrier that ensures all previously encoded commands have
+  ///        finished reading or writing to any textures subsequent commands
+  ///        will access it.
+  ///
+  ///        This only handles read after write hazards.
+  virtual void AddTextureMemoryBarrier() = 0;
+
   //----------------------------------------------------------------------------
   /// @brief      Encode the recorded commands to the underlying command buffer.
   ///
@@ -43,6 +56,8 @@ class ComputePass : public ResourceBinder {
   ///
   virtual bool EncodeCommands() const = 0;
 
+  const Context& GetContext() const { return *context_; }
+
  protected:
   const std::shared_ptr<const Context> context_;
 

impeller/renderer/compute_unittests.cc

@@ -308,6 +308,7 @@ TEST_P(ComputeTest, MultiStageInputAndOutput) {
     CS1::BindOutput(*pass, DeviceBuffer::AsBufferView(output_buffer_1));
 
     ASSERT_TRUE(pass->Compute(ISize(512, 1)).ok());
+    pass->AddBufferMemoryBarrier();
   }
 
   {