Implement buffer lazy initialization before writeBuffer

This patch implements buffer lazy initialization before writeBuffer():
if the buffer is not initialized and writeBuffer() doesn't cover the
whole buffer, the buffer will be cleared to 0, otherwise the buffer
shouldn't be cleared.

This patch also introduces a toggle LazyClearBufferOnFirstUse for the
development of buffer lazy initialization: before buffer lazy
initialization being completely supported, all the related code will
only be enabled behind this toggle to prevent the buffers with valid
content being unexpectedly cleared.

BUG=dawn:414
TEST=dawn_end2end_tests

Change-Id: I99a2aa98ca4b9b21d69c6b32080afb525e2c4ad3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24041
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
diff --git a/src/dawn_native/Buffer.cpp b/src/dawn_native/Buffer.cpp
index 0e4c384..0414159 100644
--- a/src/dawn_native/Buffer.cpp
+++ b/src/dawn_native/Buffer.cpp
@@ -488,6 +488,10 @@
         mState = BufferState::Destroyed;
     }
 
+    bool BufferBase::IsMapped() const {
+        return mState == BufferState::Mapped;
+    }
+
     void BufferBase::OnMapCommandSerialFinished(uint32_t mapSerial, bool isWrite) {
         void* data = GetMappedPointerImpl();
         if (isWrite) {
@@ -497,4 +501,16 @@
         }
     }
 
+    bool BufferBase::IsDataInitialized() const {
+        return mIsDataInitialized;
+    }
+
+    void BufferBase::SetIsDataInitialized() {
+        mIsDataInitialized = true;
+    }
+
+    bool BufferBase::IsFullBufferRange(uint64_t offset, uint64_t size) const {
+        return offset == 0 && size == GetSize();
+    }
+
 }  // namespace dawn_native
diff --git a/src/dawn_native/Buffer.h b/src/dawn_native/Buffer.h
index c4f1d32..ea67fab 100644
--- a/src/dawn_native/Buffer.h
+++ b/src/dawn_native/Buffer.h
@@ -40,8 +40,6 @@
         };
 
       public:
-        enum class ClearValue { Zero, NonZero };
-
         BufferBase(DeviceBase* device, const BufferDescriptor* descriptor);
 
         static BufferBase* MakeError(DeviceBase* device);
@@ -57,6 +55,10 @@
 
         MaybeError ValidateCanUseOnQueueNow() const;
 
+        bool IsFullBufferRange(uint64_t offset, uint64_t size) const;
+        bool IsDataInitialized() const;
+        void SetIsDataInitialized();
+
         // Dawn API
         void SetSubData(uint64_t start, uint64_t count, const void* data);
         void MapReadAsync(WGPUBufferMapReadCallback callback, void* userdata);
@@ -81,6 +83,8 @@
 
         void DestroyInternal();
 
+        bool IsMapped() const;
+
       private:
         virtual MaybeError MapAtCreationImpl(uint8_t** mappedPointer) = 0;
         virtual MaybeError MapReadAsyncImpl(uint32_t serial) = 0;
@@ -109,6 +113,8 @@
         std::unique_ptr<StagingBufferBase> mStagingBuffer;
 
         BufferState mState;
+
+        bool mIsDataInitialized = false;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/Toggles.cpp b/src/dawn_native/Toggles.cpp
index 9eb526a..7f40ebd 100644
--- a/src/dawn_native/Toggles.cpp
+++ b/src/dawn_native/Toggles.cpp
@@ -29,111 +29,116 @@
         using ToggleEnumAndInfoList =
             std::array<ToggleEnumAndInfo, static_cast<size_t>(Toggle::EnumCount)>;
 
-        static constexpr ToggleEnumAndInfoList kToggleNameAndInfoList = {{
-            {Toggle::EmulateStoreAndMSAAResolve,
-             {"emulate_store_and_msaa_resolve",
-              "Emulate storing into multisampled color attachments and doing MSAA resolve "
-              "simultaneously. This workaround is enabled by default on the Metal drivers that do "
-              "not support MTLStoreActionStoreAndMultisampleResolve. To support StoreOp::Store on "
-              "those platforms, we should do MSAA resolve in another render pass after ending the "
-              "previous one.",
-              "https://crbug.com/dawn/56"}},
-            {Toggle::NonzeroClearResourcesOnCreationForTesting,
-             {"nonzero_clear_resources_on_creation_for_testing",
-              "Clears texture to full 1 bits as soon as they are created, but doesn't update "
-              "the tracking state of the texture. This way we can test the logic of clearing "
-              "textures that use recycled memory.",
-              "https://crbug.com/dawn/145"}},
-            {Toggle::AlwaysResolveIntoZeroLevelAndLayer,
-             {"always_resolve_into_zero_level_and_layer",
-              "When the resolve target is a texture view that is created on the non-zero level or "
-              "layer of a texture, we first resolve into a temporarily 2D texture with only one "
-              "mipmap level and one array layer, and copy the result of MSAA resolve into the "
-              "true resolve target. This workaround is enabled by default on the Metal drivers "
-              "that have bugs when setting non-zero resolveLevel or resolveSlice.",
-              "https://crbug.com/dawn/56"}},
-            {Toggle::LazyClearResourceOnFirstUse,
-             {"lazy_clear_resource_on_first_use",
-              "Clears resource to zero on first usage. This initializes the resource "
-              "so that no dirty bits from recycled memory is present in the new resource.",
-              "https://crbug.com/dawn/145"}},
-            {Toggle::TurnOffVsync,
-             {"turn_off_vsync",
-              "Turn off vsync when rendering. In order to do performance test or run perf tests, "
-              "turn off vsync so that the fps can exeed 60.",
-              "https://crbug.com/dawn/237"}},
-            {Toggle::UseTemporaryBufferInCompressedTextureToTextureCopy,
-             {"use_temporary_buffer_in_texture_to_texture_copy",
-              "Split texture-to-texture copy into two copies: copy from source texture into a "
-              "temporary buffer, and copy from the temporary buffer into the destination texture "
-              "when copying between compressed textures that don't have block-aligned sizes. This "
-              "workaround is enabled by default on all Vulkan drivers to solve an issue in the "
-              "Vulkan SPEC about the texture-to-texture copies with compressed formats. See #1005 "
-              "(https://github.com/KhronosGroup/Vulkan-Docs/issues/1005) for more details.",
-              "https://crbug.com/dawn/42"}},
-            {Toggle::UseD3D12ResourceHeapTier2,
-             {"use_d3d12_resource_heap_tier2",
-              "Enable support for resource heap tier 2. Resource heap tier 2 allows mixing of "
-              "texture and buffers in the same heap. This allows better heap re-use and reduces "
-              "fragmentation.",
-              "https://crbug.com/dawn/27"}},
-            {Toggle::UseD3D12RenderPass,
-             {"use_d3d12_render_pass",
-              "Use the D3D12 render pass API introduced in Windows build 1809 by default. On "
-              "versions of Windows prior to build 1809, or when this toggle is turned off, Dawn "
-              "will emulate a render pass.",
-              "https://crbug.com/dawn/36"}},
-            {Toggle::UseD3D12ResidencyManagement,
-             {"use_d3d12_residency_management",
-              "Enable residency management. This allows page-in and page-out of resource heaps in "
-              "GPU memory. This component improves overcommitted performance by keeping the most "
-              "recently used resources local to the GPU. Turning this component off can cause "
-              "allocation failures when application memory exceeds physical device memory.",
-              "https://crbug.com/dawn/193"}},
-            {Toggle::SkipValidation,
-             {"skip_validation", "Skip expensive validation of Dawn commands.",
-              "https://crbug.com/dawn/271"}},
-            {Toggle::UseSpvc,
-             {"use_spvc",
-              "Enable use of spvc for shader compilation, instead of accessing spirv_cross "
-              "directly.",
-              "https://crbug.com/dawn/288"}},
-            {Toggle::UseSpvcParser,
-             {"use_spvc_parser",
-              "Enable usage of spvc's internal parsing and IR generation code, instead of "
-              "spirv_cross's.",
-              "https://crbug.com/dawn/288"}},
-            {Toggle::VulkanUseD32S8,
-             {"vulkan_use_d32s8",
-              "Vulkan mandates support of either D32_FLOAT_S8 or D24_UNORM_S8. When available the "
-              "backend will use D32S8 (toggle to on) but setting the toggle to off will make it"
-              "use the D24S8 format when possible.",
-              "https://crbug.com/dawn/286"}},
-            {Toggle::MetalDisableSamplerCompare,
-             {"metal_disable_sampler_compare",
-              "Disables the use of sampler compare on Metal. This is unsupported before A9 "
-              "processors.",
-              "https://crbug.com/dawn/342"}},
-            {Toggle::DisableBaseVertex,
-             {"disable_base_vertex",
-              "Disables the use of non-zero base vertex which is unsupported on some platforms.",
-              "https://crbug.com/dawn/343"}},
-            {Toggle::DisableBaseInstance,
-             {"disable_base_instance",
-              "Disables the use of non-zero base instance which is unsupported on some "
-              "platforms.",
-              "https://crbug.com/dawn/343"}},
-            {Toggle::UseD3D12SmallShaderVisibleHeapForTesting,
-             {"use_d3d12_small_shader_visible_heap",
-              "Enable use of a small D3D12 shader visible heap, instead of using a large one by "
-              "default. This setting is used to test bindgroup encoding.",
-              "https://crbug.com/dawn/155"}},
-            {Toggle::UseDXC,
-             {"use_dxc", "Use DXC instead of FXC for compiling HLSL",
-              "https://crbug.com/dawn/402"}},
-            {Toggle::DisableRobustness,
-             {"disable_robustness", "Disable robust buffer access", "https://crbug.com/dawn/480"}},
-        }};
+        static constexpr ToggleEnumAndInfoList kToggleNameAndInfoList = {
+            {{Toggle::EmulateStoreAndMSAAResolve,
+              {"emulate_store_and_msaa_resolve",
+               "Emulate storing into multisampled color attachments and doing MSAA resolve "
+               "simultaneously. This workaround is enabled by default on the Metal drivers that do "
+               "not support MTLStoreActionStoreAndMultisampleResolve. To support StoreOp::Store on "
+               "those platforms, we should do MSAA resolve in another render pass after ending the "
+               "previous one.",
+               "https://crbug.com/dawn/56"}},
+             {Toggle::NonzeroClearResourcesOnCreationForTesting,
+              {"nonzero_clear_resources_on_creation_for_testing",
+               "Clears texture to full 1 bits as soon as they are created, but doesn't update "
+               "the tracking state of the texture. This way we can test the logic of clearing "
+               "textures that use recycled memory.",
+               "https://crbug.com/dawn/145"}},
+             {Toggle::AlwaysResolveIntoZeroLevelAndLayer,
+              {"always_resolve_into_zero_level_and_layer",
+               "When the resolve target is a texture view that is created on the non-zero level or "
+               "layer of a texture, we first resolve into a temporarily 2D texture with only one "
+               "mipmap level and one array layer, and copy the result of MSAA resolve into the "
+               "true resolve target. This workaround is enabled by default on the Metal drivers "
+               "that have bugs when setting non-zero resolveLevel or resolveSlice.",
+               "https://crbug.com/dawn/56"}},
+             {Toggle::LazyClearResourceOnFirstUse,
+              {"lazy_clear_resource_on_first_use",
+               "Clears resource to zero on first usage. This initializes the resource "
+               "so that no dirty bits from recycled memory is present in the new resource.",
+               "https://crbug.com/dawn/145"}},
+             {Toggle::TurnOffVsync,
+              {"turn_off_vsync",
+               "Turn off vsync when rendering. In order to do performance test or run perf tests, "
+               "turn off vsync so that the fps can exeed 60.",
+               "https://crbug.com/dawn/237"}},
+             {Toggle::UseTemporaryBufferInCompressedTextureToTextureCopy,
+              {"use_temporary_buffer_in_texture_to_texture_copy",
+               "Split texture-to-texture copy into two copies: copy from source texture into a "
+               "temporary buffer, and copy from the temporary buffer into the destination texture "
+               "when copying between compressed textures that don't have block-aligned sizes. This "
+               "workaround is enabled by default on all Vulkan drivers to solve an issue in the "
+               "Vulkan SPEC about the texture-to-texture copies with compressed formats. See #1005 "
+               "(https://github.com/KhronosGroup/Vulkan-Docs/issues/1005) for more details.",
+               "https://crbug.com/dawn/42"}},
+             {Toggle::UseD3D12ResourceHeapTier2,
+              {"use_d3d12_resource_heap_tier2",
+               "Enable support for resource heap tier 2. Resource heap tier 2 allows mixing of "
+               "texture and buffers in the same heap. This allows better heap re-use and reduces "
+               "fragmentation.",
+               "https://crbug.com/dawn/27"}},
+             {Toggle::UseD3D12RenderPass,
+              {"use_d3d12_render_pass",
+               "Use the D3D12 render pass API introduced in Windows build 1809 by default. On "
+               "versions of Windows prior to build 1809, or when this toggle is turned off, Dawn "
+               "will emulate a render pass.",
+               "https://crbug.com/dawn/36"}},
+             {Toggle::UseD3D12ResidencyManagement,
+              {"use_d3d12_residency_management",
+               "Enable residency management. This allows page-in and page-out of resource heaps in "
+               "GPU memory. This component improves overcommitted performance by keeping the most "
+               "recently used resources local to the GPU. Turning this component off can cause "
+               "allocation failures when application memory exceeds physical device memory.",
+               "https://crbug.com/dawn/193"}},
+             {Toggle::SkipValidation,
+              {"skip_validation", "Skip expensive validation of Dawn commands.",
+               "https://crbug.com/dawn/271"}},
+             {Toggle::UseSpvc,
+              {"use_spvc",
+               "Enable use of spvc for shader compilation, instead of accessing spirv_cross "
+               "directly.",
+               "https://crbug.com/dawn/288"}},
+             {Toggle::UseSpvcParser,
+              {"use_spvc_parser",
+               "Enable usage of spvc's internal parsing and IR generation code, instead of "
+               "spirv_cross's.",
+               "https://crbug.com/dawn/288"}},
+             {Toggle::VulkanUseD32S8,
+              {"vulkan_use_d32s8",
+               "Vulkan mandates support of either D32_FLOAT_S8 or D24_UNORM_S8. When available the "
+               "backend will use D32S8 (toggle to on) but setting the toggle to off will make it"
+               "use the D24S8 format when possible.",
+               "https://crbug.com/dawn/286"}},
+             {Toggle::MetalDisableSamplerCompare,
+              {"metal_disable_sampler_compare",
+               "Disables the use of sampler compare on Metal. This is unsupported before A9 "
+               "processors.",
+               "https://crbug.com/dawn/342"}},
+             {Toggle::DisableBaseVertex,
+              {"disable_base_vertex",
+               "Disables the use of non-zero base vertex which is unsupported on some platforms.",
+               "https://crbug.com/dawn/343"}},
+             {Toggle::DisableBaseInstance,
+              {"disable_base_instance",
+               "Disables the use of non-zero base instance which is unsupported on some "
+               "platforms.",
+               "https://crbug.com/dawn/343"}},
+             {Toggle::UseD3D12SmallShaderVisibleHeapForTesting,
+              {"use_d3d12_small_shader_visible_heap",
+               "Enable use of a small D3D12 shader visible heap, instead of using a large one by "
+               "default. This setting is used to test bindgroup encoding.",
+               "https://crbug.com/dawn/155"}},
+             {Toggle::UseDXC,
+              {"use_dxc", "Use DXC instead of FXC for compiling HLSL",
+               "https://crbug.com/dawn/402"}},
+             {Toggle::DisableRobustness,
+              {"disable_robustness", "Disable robust buffer access", "https://crbug.com/dawn/480"}},
+             {Toggle::LazyClearBufferOnFirstUse,
+              {"lazy_clear_buffer_on_first_use",
+               "Clear buffers on their first use. This is a temporary toggle only for the "
+               "development of buffer lazy initialization and will be removed after buffer lazy "
+               "initialization is completely implemented.",
+               "https://crbug.com/dawn/414"}}}};
 
     }  // anonymous namespace
 
diff --git a/src/dawn_native/Toggles.h b/src/dawn_native/Toggles.h
index 1e7e3e3..f9d66a2 100644
--- a/src/dawn_native/Toggles.h
+++ b/src/dawn_native/Toggles.h
@@ -43,6 +43,7 @@
         UseD3D12SmallShaderVisibleHeapForTesting,
         UseDXC,
         DisableRobustness,
+        LazyClearBufferOnFirstUse,
 
         EnumCount,
         InvalidEnum = EnumCount,
diff --git a/src/dawn_native/d3d12/BufferD3D12.cpp b/src/dawn_native/d3d12/BufferD3D12.cpp
index 65adaf0..a7b8fd8 100644
--- a/src/dawn_native/d3d12/BufferD3D12.cpp
+++ b/src/dawn_native/d3d12/BufferD3D12.cpp
@@ -123,7 +123,11 @@
             ToBackend(GetDevice())->AllocateMemory(heapType, resourceDescriptor, bufferUsage));
 
         if (GetDevice()->IsToggleEnabled(Toggle::NonzeroClearResourcesOnCreationForTesting)) {
-            DAWN_TRY(ClearBuffer(ClearValue::NonZero));
+            CommandRecordingContext* commandRecordingContext;
+            DAWN_TRY_ASSIGN(commandRecordingContext,
+                            ToBackend(GetDevice())->GetPendingCommandContext());
+
+            DAWN_TRY(ClearBuffer(commandRecordingContext, uint8_t(1u)));
         }
 
         return {};
@@ -310,18 +314,25 @@
         return mResourceAllocation.GetInfo().mMethod == allocationMethod;
     }
 
-    MaybeError Buffer::ClearBuffer(ClearValue clearValue) {
-        // TODO(jiawei.shao@intel.com): support buffer lazy-initialization to 0.
-        ASSERT(clearValue == BufferBase::ClearValue::NonZero);
-        constexpr uint8_t kClearBufferValue = 1u;
+    MaybeError Buffer::ClearBufferContentsToZero(CommandRecordingContext* commandContext) {
+        ASSERT(GetDevice()->IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse));
+        ASSERT(!IsDataInitialized());
 
+        DAWN_TRY(ClearBuffer(commandContext, uint8_t(0u)));
+        SetIsDataInitialized();
+        GetDevice()->IncrementLazyClearCountForTesting();
+
+        return {};
+    }
+
+    MaybeError Buffer::ClearBuffer(CommandRecordingContext* commandContext, uint8_t clearValue) {
         Device* device = ToBackend(GetDevice());
 
         // The state of the buffers on UPLOAD heap must always be GENERIC_READ and cannot be
         // changed away, so we can only clear such buffer with buffer mapping.
         if (D3D12HeapType(GetUsage()) == D3D12_HEAP_TYPE_UPLOAD) {
             DAWN_TRY(MapInternal(true, "D3D12 map at clear buffer"));
-            memset(mMappedData, kClearBufferValue, GetSize());
+            memset(mMappedData, clearValue, GetSize());
             UnmapImpl();
         } else {
             // TODO(jiawei.shao@intel.com): use ClearUnorderedAccessView*() when the buffer usage
@@ -331,10 +342,10 @@
             DAWN_TRY_ASSIGN(uploadHandle,
                             uploader->Allocate(GetSize(), device->GetPendingCommandSerial()));
 
-            memset(uploadHandle.mappedBuffer, kClearBufferValue, GetSize());
+            memset(uploadHandle.mappedBuffer, clearValue, GetSize());
 
-            DAWN_TRY(device->CopyFromStagingToBuffer(uploadHandle.stagingBuffer,
-                                                     uploadHandle.startOffset, this, 0, GetSize()));
+            device->CopyFromStagingToBufferImpl(commandContext, uploadHandle.stagingBuffer,
+                                                uploadHandle.startOffset, this, 0, GetSize());
         }
 
         return {};
diff --git a/src/dawn_native/d3d12/BufferD3D12.h b/src/dawn_native/d3d12/BufferD3D12.h
index a081986..a364250 100644
--- a/src/dawn_native/d3d12/BufferD3D12.h
+++ b/src/dawn_native/d3d12/BufferD3D12.h
@@ -44,6 +44,8 @@
         bool CheckAllocationMethodForTesting(AllocationMethod allocationMethod) const;
         bool CheckIsResidentForTesting() const;
 
+        MaybeError ClearBufferContentsToZero(CommandRecordingContext* commandContext);
+
       private:
         ~Buffer() override;
         // Dawn API
@@ -61,7 +63,7 @@
                                                   D3D12_RESOURCE_BARRIER* barrier,
                                                   wgpu::BufferUsage newUsage);
 
-        MaybeError ClearBuffer(ClearValue clearValue);
+        MaybeError ClearBuffer(CommandRecordingContext* commandContext, uint8_t clearValue);
 
         ResourceHeapAllocation mResourceAllocation;
         bool mFixedResourceState = false;
diff --git a/src/dawn_native/d3d12/DeviceD3D12.cpp b/src/dawn_native/d3d12/DeviceD3D12.cpp
index d4b9b51..7ecb984 100644
--- a/src/dawn_native/d3d12/DeviceD3D12.cpp
+++ b/src/dawn_native/d3d12/DeviceD3D12.cpp
@@ -336,16 +336,39 @@
         DAWN_TRY_ASSIGN(commandRecordingContext, GetPendingCommandContext());
 
         Buffer* dstBuffer = ToBackend(destination);
-        StagingBuffer* srcBuffer = ToBackend(source);
-        dstBuffer->TrackUsageAndTransitionNow(commandRecordingContext, wgpu::BufferUsage::CopyDst);
 
-        commandRecordingContext->GetCommandList()->CopyBufferRegion(
-            dstBuffer->GetD3D12Resource(), destinationOffset, srcBuffer->GetResource(),
-            sourceOffset, size);
+        // TODO(jiawei.shao@intel.com): use Toggle::LazyClearResourceOnFirstUse when the support of
+        // buffer lazy initialization is completed.
+        if (IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse) && !dstBuffer->IsDataInitialized()) {
+            if (dstBuffer->IsFullBufferRange(destinationOffset, size)) {
+                dstBuffer->SetIsDataInitialized();
+            } else {
+                DAWN_TRY(dstBuffer->ClearBufferContentsToZero(commandRecordingContext));
+            }
+        }
+
+        CopyFromStagingToBufferImpl(commandRecordingContext, source, sourceOffset, destination,
+                                    destinationOffset, size);
 
         return {};
     }
 
+    void Device::CopyFromStagingToBufferImpl(CommandRecordingContext* commandContext,
+                                             StagingBufferBase* source,
+                                             uint64_t sourceOffset,
+                                             BufferBase* destination,
+                                             uint64_t destinationOffset,
+                                             uint64_t size) {
+        ASSERT(commandContext != nullptr);
+        Buffer* dstBuffer = ToBackend(destination);
+        StagingBuffer* srcBuffer = ToBackend(source);
+        dstBuffer->TrackUsageAndTransitionNow(commandContext, wgpu::BufferUsage::CopyDst);
+
+        commandContext->GetCommandList()->CopyBufferRegion(
+            dstBuffer->GetD3D12Resource(), destinationOffset, srcBuffer->GetResource(),
+            sourceOffset, size);
+    }
+
     void Device::DeallocateMemory(ResourceHeapAllocation& allocation) {
         mResourceAllocatorManager->DeallocateMemory(allocation);
     }
diff --git a/src/dawn_native/d3d12/DeviceD3D12.h b/src/dawn_native/d3d12/DeviceD3D12.h
index 1ee4092..983ed67 100644
--- a/src/dawn_native/d3d12/DeviceD3D12.h
+++ b/src/dawn_native/d3d12/DeviceD3D12.h
@@ -91,6 +91,13 @@
                                            uint64_t destinationOffset,
                                            uint64_t size) override;
 
+        void CopyFromStagingToBufferImpl(CommandRecordingContext* commandContext,
+                                         StagingBufferBase* source,
+                                         uint64_t sourceOffset,
+                                         BufferBase* destination,
+                                         uint64_t destinationOffset,
+                                         uint64_t size);
+
         ResultOrError<ResourceHeapAllocation> AllocateMemory(
             D3D12_HEAP_TYPE heapType,
             const D3D12_RESOURCE_DESC& resourceDescriptor,
diff --git a/src/dawn_native/metal/BufferMTL.h b/src/dawn_native/metal/BufferMTL.h
index 98bab96..f204e53 100644
--- a/src/dawn_native/metal/BufferMTL.h
+++ b/src/dawn_native/metal/BufferMTL.h
@@ -22,6 +22,7 @@
 
 namespace dawn_native { namespace metal {
 
+    class CommandRecordingContext;
     class Device;
 
     class Buffer : public BufferBase {
@@ -29,6 +30,8 @@
         static ResultOrError<Buffer*> Create(Device* device, const BufferDescriptor* descriptor);
         id<MTLBuffer> GetMTLBuffer() const;
 
+        void ClearBufferContentsToZero(CommandRecordingContext* commandContext);
+
       private:
         using BufferBase::BufferBase;
         MaybeError Initialize();
@@ -43,7 +46,7 @@
         bool IsMapWritable() const override;
         MaybeError MapAtCreationImpl(uint8_t** mappedPointer) override;
 
-        void ClearBuffer(BufferBase::ClearValue clearValue);
+        void ClearBuffer(CommandRecordingContext* commandContext, uint8_t clearValue);
 
         id<MTLBuffer> mMtlBuffer = nil;
     };
diff --git a/src/dawn_native/metal/BufferMTL.mm b/src/dawn_native/metal/BufferMTL.mm
index 46724bf..858eab6 100644
--- a/src/dawn_native/metal/BufferMTL.mm
+++ b/src/dawn_native/metal/BufferMTL.mm
@@ -15,6 +15,7 @@
 #include "dawn_native/metal/BufferMTL.h"
 
 #include "common/Math.h"
+#include "dawn_native/metal/CommandRecordingContext.h"
 #include "dawn_native/metal/DeviceMTL.h"
 
 #include <limits>
@@ -87,7 +88,9 @@
         }
 
         if (GetDevice()->IsToggleEnabled(Toggle::NonzeroClearResourcesOnCreationForTesting)) {
-            ClearBuffer(BufferBase::ClearValue::NonZero);
+            CommandRecordingContext* commandContext =
+                ToBackend(GetDevice())->GetPendingCommandContext();
+            ClearBuffer(commandContext, uint8_t(1u));
         }
 
         return {};
@@ -132,16 +135,21 @@
         mMtlBuffer = nil;
     }
 
-    void Buffer::ClearBuffer(BufferBase::ClearValue clearValue) {
-        // TODO(jiawei.shao@intel.com): support buffer lazy-initialization to 0.
-        ASSERT(clearValue == BufferBase::ClearValue::NonZero);
-        const uint8_t clearBufferValue = 1;
+    void Buffer::ClearBufferContentsToZero(CommandRecordingContext* commandContext) {
+        ASSERT(GetDevice()->IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse));
+        ASSERT(!IsDataInitialized());
 
-        Device* device = ToBackend(GetDevice());
-        CommandRecordingContext* commandContext = device->GetPendingCommandContext();
+        ClearBuffer(commandContext, uint8_t(0u));
+
+        SetIsDataInitialized();
+        GetDevice()->IncrementLazyClearCountForTesting();
+    }
+
+    void Buffer::ClearBuffer(CommandRecordingContext* commandContext, uint8_t clearValue) {
+        ASSERT(commandContext != nullptr);
         [commandContext->EnsureBlit() fillBuffer:mMtlBuffer
                                            range:NSMakeRange(0, GetSize())
-                                           value:clearBufferValue];
+                                           value:clearValue];
     }
 
 }}  // namespace dawn_native::metal
diff --git a/src/dawn_native/metal/DeviceMTL.mm b/src/dawn_native/metal/DeviceMTL.mm
index d8d0feb..40875c5 100644
--- a/src/dawn_native/metal/DeviceMTL.mm
+++ b/src/dawn_native/metal/DeviceMTL.mm
@@ -254,6 +254,17 @@
         // this function.
         ASSERT(size != 0);
 
+        // TODO(jiawei.shao@intel.com): use Toggle::LazyClearResourceOnFirstUse when the support of
+        // buffer lazy initialization is completed.
+        if (IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse) &&
+            !destination->IsDataInitialized()) {
+            if (destination->IsFullBufferRange(destinationOffset, size)) {
+                destination->SetIsDataInitialized();
+            } else {
+                ToBackend(destination)->ClearBufferContentsToZero(GetPendingCommandContext());
+            }
+        }
+
         id<MTLBuffer> uploadBuffer = ToBackend(source)->GetBufferHandle();
         id<MTLBuffer> buffer = ToBackend(destination)->GetMTLBuffer();
         [GetPendingCommandContext()->EnsureBlit() copyFromBuffer:uploadBuffer
diff --git a/src/dawn_native/null/DeviceNull.cpp b/src/dawn_native/null/DeviceNull.cpp
index fd91585..b654347 100644
--- a/src/dawn_native/null/DeviceNull.cpp
+++ b/src/dawn_native/null/DeviceNull.cpp
@@ -197,6 +197,10 @@
                                                BufferBase* destination,
                                                uint64_t destinationOffset,
                                                uint64_t size) {
+        if (IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse)) {
+            destination->SetIsDataInitialized();
+        }
+
         auto operation = std::make_unique<CopyFromStagingToBufferOperation>();
         operation->staging = source;
         operation->destination = ToBackend(destination);
diff --git a/src/dawn_native/opengl/BufferGL.cpp b/src/dawn_native/opengl/BufferGL.cpp
index 7e91a49..f9839bd 100644
--- a/src/dawn_native/opengl/BufferGL.cpp
+++ b/src/dawn_native/opengl/BufferGL.cpp
@@ -24,7 +24,7 @@
         : BufferBase(device, descriptor) {
         // TODO(cwallez@chromium.org): Have a global "zero" buffer instead of creating a new 4-byte
         // buffer?
-        uint64_t size = std::max(GetSize(), uint64_t(4u));
+        uint64_t size = GetAppliedSize();
 
         device->gl.GenBuffers(1, &mBuffer);
         device->gl.BindBuffer(GL_ARRAY_BUFFER, mBuffer);
@@ -45,6 +45,27 @@
         return mBuffer;
     }
 
+    uint64_t Buffer::GetAppliedSize() const {
+        // TODO(cwallez@chromium.org): Have a global "zero" buffer instead of creating a new 4-byte
+        // buffer?
+        return std::max(GetSize(), uint64_t(4u));
+    }
+
+    void Buffer::ClearBufferContentsToZero() {
+        ASSERT(GetDevice()->IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse));
+        ASSERT(!IsDataInitialized());
+
+        const uint64_t size = GetAppliedSize();
+        Device* device = ToBackend(GetDevice());
+
+        const std::vector<uint8_t> clearValues(size, 0u);
+        device->gl.BindBuffer(GL_ARRAY_BUFFER, mBuffer);
+        device->gl.BufferSubData(GL_ARRAY_BUFFER, 0, size, clearValues.data());
+
+        SetIsDataInitialized();
+        device->IncrementLazyClearCountForTesting();
+    }
+
     bool Buffer::IsMapWritable() const {
         // TODO(enga): All buffers in GL can be mapped. Investigate if mapping them will cause the
         // driver to migrate it to shared memory.
diff --git a/src/dawn_native/opengl/BufferGL.h b/src/dawn_native/opengl/BufferGL.h
index 9949829..272af03 100644
--- a/src/dawn_native/opengl/BufferGL.h
+++ b/src/dawn_native/opengl/BufferGL.h
@@ -29,6 +29,8 @@
 
         GLuint GetHandle() const;
 
+        void ClearBufferContentsToZero();
+
       private:
         ~Buffer() override;
         // Dawn API
@@ -40,6 +42,7 @@
         bool IsMapWritable() const override;
         MaybeError MapAtCreationImpl(uint8_t** mappedPointer) override;
         void* GetMappedPointerImpl() override;
+        uint64_t GetAppliedSize() const;
 
         GLuint mBuffer = 0;
         void* mMappedData = nullptr;
diff --git a/src/dawn_native/opengl/QueueGL.cpp b/src/dawn_native/opengl/QueueGL.cpp
index a33cbd0..2547f17 100644
--- a/src/dawn_native/opengl/QueueGL.cpp
+++ b/src/dawn_native/opengl/QueueGL.cpp
@@ -44,6 +44,17 @@
                                       size_t size) {
         const OpenGLFunctions& gl = ToBackend(GetDevice())->gl;
 
+        // TODO(jiawei.shao@intel.com): use Toggle::LazyClearResourceOnFirstUse when the support of
+        // buffer lazy initialization is completed.
+        if (GetDevice()->IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse) &&
+            !buffer->IsDataInitialized()) {
+            if (buffer->IsFullBufferRange(bufferOffset, size)) {
+                buffer->SetIsDataInitialized();
+            } else {
+                ToBackend(buffer)->ClearBufferContentsToZero();
+            }
+        }
+
         gl.BindBuffer(GL_ARRAY_BUFFER, ToBackend(buffer)->GetHandle());
         gl.BufferSubData(GL_ARRAY_BUFFER, bufferOffset, size, data);
         return {};
diff --git a/src/dawn_native/vulkan/BufferVk.cpp b/src/dawn_native/vulkan/BufferVk.cpp
index 0b9385e..74e8469 100644
--- a/src/dawn_native/vulkan/BufferVk.cpp
+++ b/src/dawn_native/vulkan/BufferVk.cpp
@@ -166,7 +166,7 @@
             "vkBindBufferMemory"));
 
         if (device->IsToggleEnabled(Toggle::NonzeroClearResourcesOnCreationForTesting)) {
-            ClearBuffer(device->GetPendingRecordingContext(), ClearValue::NonZero);
+            ClearBuffer(device->GetPendingRecordingContext(), 0x01010101);
         }
 
         return {};
@@ -287,20 +287,25 @@
         }
     }
 
-    void Buffer::ClearBuffer(CommandRecordingContext* recordingContext, ClearValue clearValue) {
+    void Buffer::ClearBufferContentsToZero(CommandRecordingContext* recordingContext) {
+        ASSERT(GetDevice()->IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse));
+        ASSERT(!IsDataInitialized());
+
+        ClearBuffer(recordingContext, 0u);
+
+        SetIsDataInitialized();
+        GetDevice()->IncrementLazyClearCountForTesting();
+    }
+
+    void Buffer::ClearBuffer(CommandRecordingContext* recordingContext, uint32_t clearValue) {
         ASSERT(recordingContext != nullptr);
 
-        // TODO(jiawei.shao@intel.com): support buffer lazy-initialization to 0.
-        ASSERT(clearValue == BufferBase::ClearValue::NonZero);
-
-        constexpr uint32_t kClearBufferValue = 0x01010101;
-
         TransitionUsageNow(recordingContext, wgpu::BufferUsage::CopyDst);
 
         Device* device = ToBackend(GetDevice());
         // TODO(jiawei.shao@intel.com): find out why VK_WHOLE_SIZE doesn't work on old Windows Intel
         // Vulkan drivers.
         device->fn.CmdFillBuffer(recordingContext->commandBuffer, mHandle, 0, GetSize(),
-                                 kClearBufferValue);
+                                 clearValue);
     }
 }}  // namespace dawn_native::vulkan
diff --git a/src/dawn_native/vulkan/BufferVk.h b/src/dawn_native/vulkan/BufferVk.h
index 1c04870..ace13a9 100644
--- a/src/dawn_native/vulkan/BufferVk.h
+++ b/src/dawn_native/vulkan/BufferVk.h
@@ -45,11 +45,13 @@
                                 VkPipelineStageFlags* srcStages,
                                 VkPipelineStageFlags* dstStages);
 
+        void ClearBufferContentsToZero(CommandRecordingContext* recordingContext);
+
       private:
         ~Buffer() override;
         using BufferBase::BufferBase;
         MaybeError Initialize();
-        void ClearBuffer(CommandRecordingContext* recordingContext, ClearValue clearValue);
+        void ClearBuffer(CommandRecordingContext* recordingContext, uint32_t clearValue);
 
         // Dawn API
         MaybeError MapReadAsyncImpl(uint32_t serial) override;
diff --git a/src/dawn_native/vulkan/DeviceVk.cpp b/src/dawn_native/vulkan/DeviceVk.cpp
index 2415b49..5a2a905 100644
--- a/src/dawn_native/vulkan/DeviceVk.cpp
+++ b/src/dawn_native/vulkan/DeviceVk.cpp
@@ -590,6 +590,19 @@
         // calling this function.
         ASSERT(size != 0);
 
+        CommandRecordingContext* recordingContext = GetPendingRecordingContext();
+
+        // TODO(jiawei.shao@intel.com): use Toggle::LazyClearResourceOnFirstUse when the support of
+        // buffer lazy initialization is completed.
+        if (IsToggleEnabled(Toggle::LazyClearBufferOnFirstUse) &&
+            !destination->IsDataInitialized()) {
+            if (destination->IsFullBufferRange(destinationOffset, size)) {
+                destination->SetIsDataInitialized();
+            } else {
+                ToBackend(destination)->ClearBufferContentsToZero(recordingContext);
+            }
+        }
+
         // Insert memory barrier to ensure host write operations are made visible before
         // copying from the staging buffer. However, this barrier can be removed (see note below).
         //
@@ -599,7 +612,6 @@
 
         // Insert pipeline barrier to ensure correct ordering with previous memory operations on the
         // buffer.
-        CommandRecordingContext* recordingContext = GetPendingRecordingContext();
         ToBackend(destination)->TransitionUsageNow(recordingContext, wgpu::BufferUsage::CopyDst);
 
         VkBufferCopy copy;
diff --git a/src/tests/BUILD.gn b/src/tests/BUILD.gn
index 201ff08..853e1f0 100644
--- a/src/tests/BUILD.gn
+++ b/src/tests/BUILD.gn
@@ -259,6 +259,7 @@
     "end2end/BasicTests.cpp",
     "end2end/BindGroupTests.cpp",
     "end2end/BufferTests.cpp",
+    "end2end/BufferZeroInitTests.cpp",
     "end2end/ClipSpaceTests.cpp",
     "end2end/ColorStateTests.cpp",
     "end2end/CompressedTextureFormatTests.cpp",
diff --git a/src/tests/end2end/BufferZeroInitTests.cpp b/src/tests/end2end/BufferZeroInitTests.cpp
new file mode 100644
index 0000000..5392e49
--- /dev/null
+++ b/src/tests/end2end/BufferZeroInitTests.cpp
@@ -0,0 +1,98 @@
+// Copyright 2020 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "tests/DawnTest.h"
+
+#include "utils/WGPUHelpers.h"
+
+#define EXPECT_LAZY_CLEAR(N, statement)                                                       \
+    do {                                                                                      \
+        if (UsesWire()) {                                                                     \
+            statement;                                                                        \
+        } else {                                                                              \
+            size_t lazyClearsBefore = dawn_native::GetLazyClearCountForTesting(device.Get()); \
+            statement;                                                                        \
+            size_t lazyClearsAfter = dawn_native::GetLazyClearCountForTesting(device.Get());  \
+            EXPECT_EQ(N, lazyClearsAfter - lazyClearsBefore);                                 \
+        }                                                                                     \
+    } while (0)
+
+class BufferZeroInitTest : public DawnTest {
+  public:
+    wgpu::Buffer CreateBuffer(uint64_t size, wgpu::BufferUsage usage) {
+        wgpu::BufferDescriptor descriptor;
+        descriptor.size = size;
+        descriptor.usage = usage;
+        return device.CreateBuffer(&descriptor);
+    }
+};
+
+// Test that calling writeBuffer to overwrite the entire buffer doesn't need to lazily initialize
+// the destination buffer.
+TEST_P(BufferZeroInitTest, WriteBufferToEntireBuffer) {
+    constexpr uint32_t kBufferSize = 8u;
+    constexpr wgpu::BufferUsage kBufferUsage =
+        wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
+    wgpu::Buffer buffer = CreateBuffer(kBufferSize, kBufferUsage);
+
+    constexpr std::array<uint32_t, kBufferSize / sizeof(uint32_t)> kExpectedData = {
+        {0x02020202u, 0x02020202u}};
+    EXPECT_LAZY_CLEAR(0u, queue.WriteBuffer(buffer, 0, kExpectedData.data(), kBufferSize));
+
+    EXPECT_BUFFER_U32_RANGE_EQ(kExpectedData.data(), buffer, 0, kBufferSize / sizeof(uint32_t));
+}
+
+// Test that calling writeBuffer to overwrite a part of buffer needs to lazily initialize the
+// destination buffer.
+TEST_P(BufferZeroInitTest, WriteBufferToSubBuffer) {
+    constexpr uint32_t kBufferSize = 8u;
+    constexpr wgpu::BufferUsage kBufferUsage =
+        wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
+
+    constexpr uint32_t kCopyValue = 0x02020202u;
+
+    // offset == 0
+    {
+        wgpu::Buffer buffer = CreateBuffer(kBufferSize, kBufferUsage);
+
+        constexpr uint32_t kCopyOffset = 0u;
+        EXPECT_LAZY_CLEAR(1u,
+                          queue.WriteBuffer(buffer, kCopyOffset, &kCopyValue, sizeof(kCopyValue)));
+
+        EXPECT_BUFFER_U32_EQ(kCopyValue, buffer, kCopyOffset);
+        EXPECT_BUFFER_U32_EQ(0, buffer, kBufferSize - sizeof(kCopyValue));
+    }
+
+    // offset > 0
+    {
+        wgpu::Buffer buffer = CreateBuffer(kBufferSize, kBufferUsage);
+
+        constexpr uint32_t kCopyOffset = 4u;
+        EXPECT_LAZY_CLEAR(1u,
+                          queue.WriteBuffer(buffer, kCopyOffset, &kCopyValue, sizeof(kCopyValue)));
+
+        EXPECT_BUFFER_U32_EQ(0, buffer, 0);
+        EXPECT_BUFFER_U32_EQ(kCopyValue, buffer, kCopyOffset);
+    }
+}
+
+DAWN_INSTANTIATE_TEST(BufferZeroInitTest,
+                      D3D12Backend({"nonzero_clear_resources_on_creation_for_testing",
+                                    "lazy_clear_buffer_on_first_use"}),
+                      MetalBackend({"nonzero_clear_resources_on_creation_for_testing",
+                                    "lazy_clear_buffer_on_first_use"}),
+                      OpenGLBackend({"nonzero_clear_resources_on_creation_for_testing",
+                                     "lazy_clear_buffer_on_first_use"}),
+                      VulkanBackend({"nonzero_clear_resources_on_creation_for_testing",
+                                     "lazy_clear_buffer_on_first_use"}));