Attachment 362052 Details for Bug 194665 – Patch

[patch] Patch

bug-194665-20190214125736.patch (text/plain), 21.93 KB, created by Justin Fan on 2019-02-14 12:57:36 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Justin Fan

Created: 2019-02-14 12:57:36 PST

Size: 21.93 KB

patch

obsolete

>Subversion Revision: 241328
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index a420326f3b772cf5f430abd161844c239e15fbd0..333947003d2b2cf2d5871e199a0cbcebd461e580 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,52 @@
>+2019-02-14  Justin Fan  <justin_fan@apple.com>
>+
>+        [WebGPU] (WIP) Buffer updates part 1: async mapping functions, unmap, and destroy
>+        https://bugs.webkit.org/show_bug.cgi?id=194665
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * Modules/webgpu/WebGPUBuffer.cpp:
>+        (WebCore::WebGPUBuffer::create):
>+        (WebCore::WebGPUBuffer::WebGPUBuffer):
>+        (WebCore::WebGPUBuffer::mapReadAsync):
>+        (WebCore::WebGPUBuffer::mapWriteAsync):
>+        (WebCore::WebGPUBuffer::unmap):
>+        (WebCore::WebGPUBuffer::destroy):
>+        * Modules/webgpu/WebGPUBuffer.h:
>+        (WebCore::WebGPUBuffer::buffer const):
>+        (WebCore::WebGPUBuffer::mapping const): Deleted.
>+        (WebCore::WebGPUBuffer::unmap): Deleted.
>+        (WebCore::WebGPUBuffer::destroy): Deleted.
>+        * Modules/webgpu/WebGPUBuffer.idl:
>+        * Modules/webgpu/WebGPUDevice.cpp:
>+        (WebCore::WebGPUDevice::createBuffer const):
>+        (WebCore::WebGPUDevice::createBindGroup const):
>+        * Modules/webgpu/WebGPUDevice.h:
>+        * Modules/webgpu/WebGPURenderPassEncoder.cpp:
>+        (WebCore::WebGPURenderPassEncoder::setVertexBuffers):
>+        * platform/graphics/gpu/GPUBuffer.h:
>+        (WebCore::GPUBuffer::isMappable const):
>+        (WebCore::GPUBuffer::isMapWriteable const):
>+        (WebCore::GPUBuffer::isMapReadable const):
>+        (WebCore::GPUBuffer::mapping const): Deleted.
>+        * platform/graphics/gpu/GPUBufferUsage.h:
>+        * platform/graphics/gpu/GPUDevice.cpp:
>+        (WebCore::GPUDevice::tryCreateBuffer const):
>+        (WebCore::GPUDevice::createBuffer const): Deleted.
>+        * platform/graphics/gpu/GPUDevice.h:
>+        * platform/graphics/gpu/cocoa/GPUBufferMetal.mm:
>+        (WebCore::GPUBuffer::tryCreateMappableBuffer):
>+        (WebCore::GPUBuffer::tryCreate):
>+        (WebCore::GPUBuffer::GPUBuffer):
>+        (WebCore::GPUBuffer::~GPUBuffer):
>+        (WebCore::GPUBuffer::resolveMappingPromise):
>+        (WebCore::GPUBuffer::mapReadAsync):
>+        (WebCore::GPUBuffer::mapWriteAsync):
>+        (WebCore::GPUBuffer::unmap):
>+        (WebCore::GPUBuffer::create): Deleted.
>+
> 2019-02-12  Justin Fan  <justin_fan@apple.com>
> 
>         [WebGPU] Remove WebGPUBufferDescriptor/Usage and use GPU versions
>diff --git a/Source/WebCore/Modules/webgpu/WebGPUBuffer.cpp b/Source/WebCore/Modules/webgpu/WebGPUBuffer.cpp
>index 909a5c7642f24af64248d999dc31c4e420f40861..003f572d975a60a135e7a750f40f9d894f3cf27f 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPUBuffer.cpp
>+++ b/Source/WebCore/Modules/webgpu/WebGPUBuffer.cpp
>@@ -28,18 +28,51 @@
> 
> #if ENABLE(WEBGPU)
> 
>+#include "Logging.h"
>+
> namespace WebCore {
> 
>-Ref<WebGPUBuffer> WebGPUBuffer::create(Ref<GPUBuffer>&& buffer)
>+Ref<WebGPUBuffer> WebGPUBuffer::create(RefPtr<GPUBuffer>&& buffer)
> {
>     return adoptRef(*new WebGPUBuffer(WTFMove(buffer)));
> }
> 
>-WebGPUBuffer::WebGPUBuffer(Ref<GPUBuffer>&& buffer)
>+WebGPUBuffer::WebGPUBuffer(RefPtr<GPUBuffer>&& buffer)
>     : m_buffer(WTFMove(buffer))
> {
> }
> 
>+void WebGPUBuffer::mapReadAsync(ArrayBufferPromise&& promise)
>+{
>+    if (m_buffer)
>+        m_buffer->mapReadAsync(WTFMove(promise));
>+    else {
>+        LOG(WebGPU, "WebGPUBuffer::mapReadAsync(): Buffer is destroyed!");
>+        promise.reject(); // FIXME: Reject with an Error object.
>+    }
>+}
>+
>+void WebGPUBuffer::mapWriteAsync(ArrayBufferPromise&& promise)
>+{
>+    if (m_buffer)
>+        m_buffer->mapWriteAsync(WTFMove(promise));
>+    else {
>+        LOG(WebGPU, "WebGPUBuffer::mapWriteAsync(): Buffer is destroyed!");
>+        promise.reject();
>+    }
>+}
>+
>+void WebGPUBuffer::unmap()
>+{
>+    if (m_buffer)
>+        m_buffer->unmap();
>+}
>+
>+void WebGPUBuffer::destroy()
>+{
>+    m_buffer = nullptr;
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(WEBGPU)
>diff --git a/Source/WebCore/Modules/webgpu/WebGPUBuffer.h b/Source/WebCore/Modules/webgpu/WebGPUBuffer.h
>index 51aebf2e2a785a19da3b0db6868adacd7cbcb248..22f1f9ded78dc78172daa50a47f8fcca6e2bafd6 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPUBuffer.h
>+++ b/Source/WebCore/Modules/webgpu/WebGPUBuffer.h
>@@ -28,26 +28,33 @@
> #if ENABLE(WEBGPU)
> 
> #include "GPUBuffer.h"
>-
>+#include "GPUBufferUsage.h"
> #include <wtf/RefCounted.h>
> #include <wtf/RefPtr.h>
> 
>+namespace JSC {
>+class ArrayBuffer;
>+}
>+
> namespace WebCore {
> 
>+struct GPUBufferDescriptor;
>+
> class WebGPUBuffer : public RefCounted<WebGPUBuffer> {
> public:
>-    static Ref<WebGPUBuffer> create(Ref<GPUBuffer>&&);
>+    static Ref<WebGPUBuffer> create(RefPtr<GPUBuffer>&&);
> 
>-    const GPUBuffer& buffer() const { return m_buffer.get(); }
>+    RefPtr<const GPUBuffer> buffer() const { return m_buffer; }
> 
>-    JSC::ArrayBuffer* mapping() const { return m_buffer->mapping(); }
>-    void unmap() { /* FIXME: Unimplemented stub. */ }
>-    void destroy() { /* FIXME: Unimplemented stub. */ }
>+    void mapReadAsync(ArrayBufferPromise&&);
>+    void mapWriteAsync(ArrayBufferPromise&&);
>+    void unmap();
>+    void destroy();
> 
> private:
>-    explicit WebGPUBuffer(Ref<GPUBuffer>&&);
>+    explicit WebGPUBuffer(RefPtr<GPUBuffer>&&);
> 
>-    Ref<GPUBuffer> m_buffer;
>+    RefPtr<GPUBuffer> m_buffer;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/webgpu/WebGPUBuffer.idl b/Source/WebCore/Modules/webgpu/WebGPUBuffer.idl
>index 308667ef4355de1d259c68a30d50a258ace88486..752ae7456e9207636f36d616f507759f94167ea6 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPUBuffer.idl
>+++ b/Source/WebCore/Modules/webgpu/WebGPUBuffer.idl
>@@ -28,7 +28,10 @@
>     EnabledAtRuntime=WebGPU,
>     ImplementationLacksVTable
> ] interface WebGPUBuffer {
>-    readonly attribute ArrayBuffer? mapping;
>+    //void setSubData(u32 offset, ArrayBuffer data);
>+
>+    Promise<ArrayBuffer> mapReadAsync();
>+    Promise<ArrayBuffer> mapWriteAsync();
>     void unmap();
> 
>     void destroy();
>diff --git a/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp b/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp
>index ea3b3c7a39ad15e93b256a405a54ec5847a5b727..767c27eb4b2e3b425f8a428fd20f9fc1b5ec4420 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp
>+++ b/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp
>@@ -73,11 +73,10 @@ WebGPUDevice::WebGPUDevice(Ref<WebGPUAdapter>&& adapter, Ref<GPUDevice>&& device
>     UNUSED_PARAM(m_adapter);
> }
> 
>-RefPtr<WebGPUBuffer> WebGPUDevice::createBuffer(GPUBufferDescriptor&& descriptor) const
>+Ref<WebGPUBuffer> WebGPUDevice::createBuffer(GPUBufferDescriptor&& descriptor) const
> {
>-    if (auto buffer = m_device->createBuffer(WTFMove(descriptor)))
>-        return WebGPUBuffer::create(buffer.releaseNonNull());
>-    return nullptr;
>+    auto buffer = m_device->tryCreateBuffer(WTFMove(descriptor));
>+    return WebGPUBuffer::create(WTFMove(buffer));
> }
> 
> Ref<WebGPUTexture> WebGPUDevice::createTexture(GPUTextureDescriptor&& descriptor) const
>@@ -119,8 +118,8 @@ Ref<WebGPUBindGroup> WebGPUDevice::createBindGroup(WebGPUBindGroupDescriptor&& d
>             return static_cast<GPUBindingResource>(view->texture());
>         return WTF::nullopt;
>     }, [] (const WebGPUBufferBinding& binding) -> Optional<GPUBindingResource> {
>-        if (binding.buffer)
>-            return static_cast<GPUBindingResource>(GPUBufferBinding { binding.buffer->buffer(), binding.offset, binding.size });
>+        if (binding.buffer && binding.buffer->buffer())
>+            return static_cast<GPUBindingResource>(GPUBufferBinding { binding.buffer->buffer().releaseNonNull(), binding.offset, binding.size });
>         return WTF::nullopt;
>     });
> 
>diff --git a/Source/WebCore/Modules/webgpu/WebGPUDevice.h b/Source/WebCore/Modules/webgpu/WebGPUDevice.h
>index a97485f8a2e5f0aeed26eacb6913d7d0c9a9ec9a..059825ac57dd00da60bba2d3521d86a15e092769 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPUDevice.h
>+++ b/Source/WebCore/Modules/webgpu/WebGPUDevice.h
>@@ -62,7 +62,7 @@ public:
>     const WebGPUAdapter& adapter() const { return m_adapter.get(); }
>     const GPUDevice& device() const { return m_device.get(); }
> 
>-    RefPtr<WebGPUBuffer> createBuffer(GPUBufferDescriptor&&) const;
>+    Ref<WebGPUBuffer> createBuffer(GPUBufferDescriptor&&) const;
>     Ref<WebGPUTexture> createTexture(GPUTextureDescriptor&&) const;
> 
>     Ref<WebGPUBindGroupLayout> createBindGroupLayout(WebGPUBindGroupLayoutDescriptor&&) const;
>diff --git a/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp b/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp
>index 03fb31bbc39cbb00f14b0c8a696df5fa6a3d3790..f9f6c8e5483896d241991eefebd87fefa354f305 100644
>--- a/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp
>+++ b/Source/WebCore/Modules/webgpu/WebGPURenderPassEncoder.cpp
>@@ -50,18 +50,26 @@ WebGPURenderPassEncoder::WebGPURenderPassEncoder(Ref<WebGPUCommandBuffer>&& crea
> void WebGPURenderPassEncoder::setVertexBuffers(unsigned long startSlot, Vector<RefPtr<WebGPUBuffer>>&& buffers, Vector<unsigned long long>&& offsets)
> {
>     if (buffers.isEmpty() || buffers.size() != offsets.size()) {
>-        LOG(WebGPU, "WebGPURenderPassEncoder::setVertexBuffers: Invalid number of buffers or offsets!");
>+        LOG(WebGPU, "WebGPURenderPassEncoder::setVertexBuffers(): Invalid number of buffers or offsets!");
>         return;
>     }
> 
>     if (startSlot + buffers.size() > maxVertexBuffers) {
>-        LOG(WebGPU, "WebGPURenderPassEncoder::setVertexBuffers: Invalid startSlot %lu for %lu buffers!", startSlot, buffers.size());
>+        LOG(WebGPU, "WebGPURenderPassEncoder::setVertexBuffers(): Invalid startSlot %lu for %lu buffers!", startSlot, buffers.size());
>         return;
>     }
> 
>-    auto gpuBuffers = buffers.map([] (const auto& buffer) -> Ref<const GPUBuffer> {
>-        return buffer->buffer();
>-    });
>+    Vector<Ref<const GPUBuffer>> gpuBuffers;
>+    gpuBuffers.reserveCapacity(buffers.size());
>+
>+    for (const auto& buffer : buffers) {
>+        if (!buffer || !buffer->buffer()) {
>+            LOG(WebGPU, "WebGPURenderPassEncoder::setVertexBuffers(): Invalid or destroyed buffer in list!");
>+            return;
>+        }
>+
>+        gpuBuffers.uncheckedAppend(buffer->buffer().releaseNonNull());
>+    }
> 
>     m_passEncoder->setVertexBuffers(startSlot, WTFMove(gpuBuffers), WTFMove(offsets));
> }
>diff --git a/Source/WebCore/platform/graphics/gpu/GPUBuffer.h b/Source/WebCore/platform/graphics/gpu/GPUBuffer.h
>index deb583dc86a9da3832e5920e0590e32e18cfeafd..81e0ce3678641d65b10db66340eb9dfed4f54ef1 100644
>--- a/Source/WebCore/platform/graphics/gpu/GPUBuffer.h
>+++ b/Source/WebCore/platform/graphics/gpu/GPUBuffer.h
>@@ -27,6 +27,8 @@
> 
> #if ENABLE(WEBGPU)
> 
>+#include "GPUBufferUsage.h"
>+#include "JSDOMPromiseDeferred.h"
> #include <wtf/Ref.h>
> #include <wtf/RefCounted.h>
> #include <wtf/RetainPtr.h>
>@@ -43,6 +45,7 @@ class GPUDevice;
> 
> struct GPUBufferDescriptor;
> 
>+using ArrayBufferPromise = DOMPromiseDeferred<IDLInterface<JSC::ArrayBuffer*>>;
> using PlatformBuffer = MTLBuffer;
> using PlatformBufferSmartPtr = RetainPtr<MTLBuffer>;
> 
>@@ -50,17 +53,29 @@ class GPUBuffer : public RefCounted<GPUBuffer> {
> public:
>     ~GPUBuffer();
> 
>-    static RefPtr<GPUBuffer> create(const GPUDevice&, GPUBufferDescriptor&&);
>+    static RefPtr<GPUBuffer> tryCreate(const GPUDevice&, GPUBufferDescriptor&&);
> 
>     PlatformBuffer *platformBuffer() const { return m_platformBuffer.get(); }
> 
>-    JSC::ArrayBuffer* mapping() const { return m_mapping.get(); }
>+    void mapReadAsync(ArrayBufferPromise&&);
>+    void mapWriteAsync(ArrayBufferPromise&&);
>+    void unmap();
> 
> private:
>-    explicit GPUBuffer(PlatformBufferSmartPtr&&, RefPtr<JSC::ArrayBuffer>&&);
>+    GPUBuffer(PlatformBufferSmartPtr&&, RefPtr<JSC::ArrayBuffer>&&, GPUBufferUsageFlags);
>+
>+    static RefPtr<GPUBuffer> tryCreateMappableBuffer(const GPUDevice&, const GPUBufferDescriptor&);
>+    void resolveMappingPromise(ArrayBufferPromise&&);
>+
>+    bool isMappable() const { return m_isMapWriteable || m_isMapReadable; }
>+    bool isMapWriteable() const { return m_isMapWriteable && !m_isMapped; }
>+    bool isMapReadable() const { return m_isMapReadable && !m_isMapped; }
> 
>     PlatformBufferSmartPtr m_platformBuffer;
>     RefPtr<JSC::ArrayBuffer> m_mapping;
>+    bool m_isMapWriteable;
>+    bool m_isMapReadable;
>+    bool m_isMapped = false;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/gpu/GPUBufferUsage.h b/Source/WebCore/platform/graphics/gpu/GPUBufferUsage.h
>index 5ab4024a1325405a5b1cf7e8dbb3998d8c2cd194..d2c4a67b07e6e7c255ddb4ebf52290f65801d44c 100644
>--- a/Source/WebCore/platform/graphics/gpu/GPUBufferUsage.h
>+++ b/Source/WebCore/platform/graphics/gpu/GPUBufferUsage.h
>@@ -35,7 +35,7 @@ using GPUBufferUsageFlags = unsigned long;
> 
> class GPUBufferUsage : public RefCounted<GPUBufferUsage> {
> public:
>-    enum class Flags : GPUBufferUsageFlags {
>+    enum Flags : GPUBufferUsageFlags {
>         None = 0,
>         MapRead = 1,
>         MapWrite = 2,
>diff --git a/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp b/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp
>index 16351e80fe7cdcad4abd434f16d9665a24690335..c6ad216e4e711a61ab460bf1724340f54900084f 100644
>--- a/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp
>+++ b/Source/WebCore/platform/graphics/gpu/GPUDevice.cpp
>@@ -44,9 +44,9 @@
> 
> namespace WebCore {
> 
>-RefPtr<GPUBuffer> GPUDevice::createBuffer(GPUBufferDescriptor&& descriptor) const
>+RefPtr<GPUBuffer> GPUDevice::tryCreateBuffer(GPUBufferDescriptor&& descriptor) const
> {
>-    return GPUBuffer::create(*this, WTFMove(descriptor));
>+    return GPUBuffer::tryCreate(*this, WTFMove(descriptor));
> }
> 
> RefPtr<GPUTexture> GPUDevice::tryCreateTexture(GPUTextureDescriptor&& descriptor) const
>diff --git a/Source/WebCore/platform/graphics/gpu/GPUDevice.h b/Source/WebCore/platform/graphics/gpu/GPUDevice.h
>index 456eb8455dd4e564c4532bd3b2c3fd6271b59b49..7fce8f483e5e448af24eb063d4fac5b70de62f17 100644
>--- a/Source/WebCore/platform/graphics/gpu/GPUDevice.h
>+++ b/Source/WebCore/platform/graphics/gpu/GPUDevice.h
>@@ -60,7 +60,7 @@ class GPUDevice : public RefCounted<GPUDevice> {
> public:
>     static RefPtr<GPUDevice> create(Optional<GPURequestAdapterOptions>&&);
> 
>-    RefPtr<GPUBuffer> createBuffer(GPUBufferDescriptor&&) const;
>+    RefPtr<GPUBuffer> tryCreateBuffer(GPUBufferDescriptor&&) const;
>     RefPtr<GPUTexture> tryCreateTexture(GPUTextureDescriptor&&) const;
> 
>     RefPtr<GPUBindGroupLayout> tryCreateBindGroupLayout(GPUBindGroupLayoutDescriptor&&) const;
>diff --git a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBufferMetal.mm b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBufferMetal.mm
>index fcc276dbe14295381b43325c0cc26dfd48534ae7..7ca78784007f1003160c2f29460783e8b73658b0 100644
>--- a/Source/WebCore/platform/graphics/gpu/cocoa/GPUBufferMetal.mm
>+++ b/Source/WebCore/platform/graphics/gpu/cocoa/GPUBufferMetal.mm
>@@ -31,8 +31,6 @@
> #import "GPUBufferDescriptor.h"
> #import "GPUDevice.h"
> #import "Logging.h"
>-
>-#import <Foundation/NSRange.h>
> #import <JavaScriptCore/ArrayBuffer.h>
> #import <Metal/Metal.h>
> #import <wtf/Gigacage.h>
>@@ -40,13 +38,8 @@
> 
> namespace WebCore {
> 
>-RefPtr<GPUBuffer> GPUBuffer::create(const GPUDevice& device, GPUBufferDescriptor&& descriptor)
>+RefPtr<GPUBuffer> GPUBuffer::tryCreateMappableBuffer(const GPUDevice& device, const GPUBufferDescriptor& descriptor)
> {
>-    if (!device.platformDevice()) {
>-        LOG(WebGPU, "GPUBuffer::create(): Invalid GPUDevice!");
>-        return nullptr;
>-    }
>-
>     size_t pageSize = WTF::pageSize();
>     size_t pageAlignedSize = roundUpToMultipleOf(pageSize, descriptor.size);
>     void* pageAlignedCopy = Gigacage::tryAlignedMalloc(Gigacage::Primitive, pageSize, pageAlignedSize);
>@@ -75,23 +68,73 @@ RefPtr<GPUBuffer> GPUBuffer::create(const GPUDevice& device, GPUBufferDescriptor
>         return nullptr;
>     }
> 
>-    return adoptRef(*new GPUBuffer(WTFMove(mtlBuffer), WTFMove(arrayBuffer)));
>+    return adoptRef(*new GPUBuffer(WTFMove(mtlBuffer), WTFMove(arrayBuffer), descriptor.usage));
> }
> 
>-GPUBuffer::GPUBuffer(PlatformBufferSmartPtr&& platformBuffer, RefPtr<ArrayBuffer>&& arrayBuffer)
>+RefPtr<GPUBuffer> GPUBuffer::tryCreate(const GPUDevice& device, GPUBufferDescriptor&& descriptor)
>+{
>+    if (!device.platformDevice()) {
>+        LOG(WebGPU, "GPUBuffer::create(): Invalid GPUDevice!");
>+        return nullptr;
>+    }
>+
>+    // FIXME: Validate combinations of GPUBufferUsageFlags as restrictions are specified.
>+
>+    // Mappable buffers need shared storage allocation.
>+    if (descriptor.usage & (GPUBufferUsage::Flags::MapWrite | GPUBufferUsage::Flags::MapRead))
>+        return tryCreateMappableBuffer(device, descriptor);
>+
>+    return nullptr;
>+}
>+
>+GPUBuffer::GPUBuffer(PlatformBufferSmartPtr&& platformBuffer, RefPtr<ArrayBuffer>&& arrayBuffer, GPUBufferUsageFlags usage)
>     : m_platformBuffer(WTFMove(platformBuffer))
>     , m_mapping(WTFMove(arrayBuffer))
>+    , m_isMapWriteable(usage & GPUBufferUsage::Flags::MapWrite)
>+    , m_isMapReadable(usage & GPUBufferUsage::Flags::MapRead)
> {
> }
> 
> GPUBuffer::~GPUBuffer()
> {
>-    if (m_mapping) {
>-        m_mapping->deref();
>-        m_mapping = nullptr;
>+    m_mapping->deref();
>+    m_mapping = nullptr;
>+}
>+
>+void GPUBuffer::resolveMappingPromise(ArrayBufferPromise&& promise)
>+{
>+    m_isMapped = true;
>+    auto mappingPtr = m_mapping.get();
>+    promise.resolve(mappingPtr);
>+}
>+
>+void GPUBuffer::mapReadAsync(ArrayBufferPromise&& promise)
>+{
>+    if (isMapReadable())
>+        resolveMappingPromise(WTFMove(promise));
>+    else {
>+        promise.reject();
>+        LOG(WebGPU, "GPUBuffer::mapReadAsync(): Invalid operation!");
>     }
> }
> 
>+void GPUBuffer::mapWriteAsync(ArrayBufferPromise&& promise)
>+{
>+    if (isMapWriteable())
>+        resolveMappingPromise(WTFMove(promise));
>+    else {
>+        promise.reject();
>+        LOG(WebGPU, "GPUBuffer::mapWriteAsync(): Invalid operation!");
>+    }
>+}
>+
>+// FIXME: MTLStorageModeShared buffers are always mapped? Or should m_mapping not be updated until buffer is unmapped?
>+void GPUBuffer::unmap()
>+{
>+    if (isMappable())
>+        m_isMapped = false;
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(WEBGPU)
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index c9dbfb9f9ba6b6504022268303ce463c16d91545..c1d9b756a909952864a7e630d5b676a1f41287de 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2019-02-14  Justin Fan  <justin_fan@apple.com>
>+
>+        [WebGPU] (WIP) Buffer updates part 1: async mapping functions, unmap, and destroy
>+        https://bugs.webkit.org/show_bug.cgi?id=194665
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * webgpu/buffer-resource-triangles.html:
>+        * webgpu/buffers.html:
>+
> 2019-02-12  Justin Fan  <justin_fan@apple.com>
> 
>         [WebGPU] Remove WebGPUBufferDescriptor/Usage and use GPU versions
>diff --git a/LayoutTests/webgpu/buffer-resource-triangles.html b/LayoutTests/webgpu/buffer-resource-triangles.html
>index 0f3a1473df1105dda9075a870986829e560fe74b..d460e53920298119c7f4549feb6c4a1a80a6f53d 100644
>--- a/LayoutTests/webgpu/buffer-resource-triangles.html
>+++ b/LayoutTests/webgpu/buffer-resource-triangles.html
>@@ -82,7 +82,7 @@ const verticesBufferSize = vertexSize * 3;
> 
> // FIXME: Keep up to date with buffer upload decisions.
> function createVerticesBuffer(device) {
>-    const buffer = device.createBuffer({ size:verticesBufferSize, usage: GPUBufferUsage.VERTEX });
>+    const buffer = device.createBuffer({ size:verticesBufferSize, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.MAP_WRITE });
> 
>     const vertices = [
>         0, 1, 0, 1,
>@@ -97,10 +97,9 @@ function createVerticesBuffer(device) {
> }
> 
> function createFloat4Buffer(device, a, b) {
>-    const buffer = device.createBuffer({ size: vertexSize, usage: GPUBufferUsage.UNIFORM });
>-    
>-    const arrayBuffer = buffer.mapping;
>-    const floatArray = new Float32Array(arrayBuffer);
>+    const buffer = device.createBuffer({ size: vertexSize, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.MAP_WRITE });
>+
>+    const floatArray = new Float32Array(buffer.mapping);
> 
>     floatArray[0] = a;
>     floatArray[1] = b;
>diff --git a/LayoutTests/webgpu/buffers.html b/LayoutTests/webgpu/buffers.html
>index 6f70f4bbd733052fdb99618ee15da71d1966f6f6..561a55e5573476ef4e15f4106cd4b3adf483fdb7 100644
>--- a/LayoutTests/webgpu/buffers.html
>+++ b/LayoutTests/webgpu/buffers.html
>@@ -7,24 +7,51 @@
> <script src="../resources/js-test-pre.js"></script>
> <script src="js/basic-webgpu-functions.js"></script>
> <script>
>-function createBuffer() {
>+function mapWriteBuffer() {
>     const buffer = defaultDevice.createBuffer({ size: 16, usage: GPUBufferUsage.MAP_WRITE });
>     assert_true(buffer instanceof WebGPUBuffer, "createBuffer returned a WebGPUBuffer");
>     
>-    let arrayBuffer = buffer.mapping;
>-    let floatArray = new Float32Array(arrayBuffer);
>-    assert_equals(floatArray.length, 4);
>-
>-    floatArray[0] = -1;
>-    floatArray[1] = 1;
>-    floatArray[2] = 0;
>-    floatArray[3] = 1;
>+    buffer.mapWriteAsync().then(arrayBuffer => {
>+        let array = new Float32Array(arrayBuffer);
>+        array.set([1, 2, 3, 4]);
>+    }).catch(() => {
>+        console.log("rejected");
>+    });
>+
>+    buffer.unmap(); // should unmap?
>+
>+    buffer.mapReadAsync().then(arrayBuffer => {
>+        // should go here, since earlier call is still in queue
>+        // Is buffer currently mapped?
>+
>+        let array = new Float32Array(arrayBuffer);
>+        assert_true(array[0] == 1, "mapWriteAsync successfully wrote");
>+
>+        return buffer.mapWriteAsync(); // should reject since buffer is still mapped
>+    })
>+    .then((arrayBuffer) => {
>+        console.log("hello");
>+    })
>+    .catch(() => {
>+        // should go here
>+        buffer.unmap();
>+
>+        buffer.mapWriteAsync().then(arrayBuffer => {
>+            let array = new Float32Array(arrayBuffer);
>+            assert_true(array[0] == 0, "mapWriteAsync zeroed out storage");
>+
>+            buffer.destroy();
>+        });
>+    });
>+
>+    // What happens if you call this here?
>+    // buffer.destroy();
> }
> 
> promise_test(async t => {
>     const canvas = document.createElement("canvas");
>     await setUpContexts(canvas);
>-    createBuffer();
>+    mapWriteBuffer();
> }, "createBuffer() on WebGPUDevice.");
> 
> </script>

Actions: View | Formatted Diff | Diff

Attachments on bug 194665: 362052 | 362062 | 362185 | 362187 | 362189 | 362198 | 362572 | 362667 | 362786 | 362792 | 362836