Source/WebCore/Modules/webgpu/WebGPUDevice.cpp

   1 /*
   2  * Copyright (C) 2018 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebGPUDevice.h"
  28
  29 #if ENABLE(WEBGPU)
  30
  31 #include "DOMWindow.h"
  32 #include "Document.h"
  33 #include "EventNames.h"
  34 #include "Exception.h"
  35 #include "GPUBindGroup.h"
  36 #include "GPUBindGroupBinding.h"
  37 #include "GPUBindGroupDescriptor.h"
  38 #include "GPUBindGroupLayoutDescriptor.h"
  39 #include "GPUBufferBinding.h"
  40 #include "GPUBufferDescriptor.h"
  41 #include "GPUCommandBuffer.h"
  42 #include "GPUComputePipelineDescriptor.h"
  43 #include "GPUProgrammableStageDescriptor.h"
  44 #include "GPURenderPipelineDescriptor.h"
  45 #include "GPUSampler.h"
  46 #include "GPUSamplerDescriptor.h"
  47 #include "GPUShaderModuleDescriptor.h"
  48 #include "GPUTextureDescriptor.h"
  49 #include "GPUUncapturedErrorEvent.h"
  50 #include "InspectorInstrumentation.h"
  51 #include "JSDOMConvertBufferSource.h"
  52 #include "JSGPUOutOfMemoryError.h"
  53 #include "JSGPUValidationError.h"
  54 #include "JSWebGPUBuffer.h"
  55 #include "Logging.h"
  56 #include "WebGPUBindGroup.h"
  57 #include "WebGPUBindGroupBinding.h"
  58 #include "WebGPUBindGroupDescriptor.h"
  59 #include "WebGPUBindGroupLayout.h"
  60 #include "WebGPUBufferBinding.h"
  61 #include "WebGPUCommandEncoder.h"
  62 #include "WebGPUComputePipeline.h"
  63 #include "WebGPUComputePipelineDescriptor.h"
  64 #include "WebGPUPipelineLayout.h"
  65 #include "WebGPUPipelineLayoutDescriptor.h"
  66 #include "WebGPUProgrammableStageDescriptor.h"
  67 #include "WebGPUQueue.h"
  68 #include "WebGPURenderPipeline.h"
  69 #include "WebGPURenderPipelineDescriptor.h"
  70 #include "WebGPUSampler.h"
  71 #include "WebGPUShaderModule.h"
  72 #include "WebGPUShaderModuleDescriptor.h"
  73 #include "WebGPUSwapChain.h"
  74 #include "WebGPUTexture.h"
  75 #include <JavaScriptCore/ConsoleMessage.h>
  76 #include <memory>
  77 #include <wtf/HashSet.h>
  78 #include <wtf/IsoMallocInlines.h>
  79 #include <wtf/Lock.h>
  80 #include <wtf/MainThread.h>
  81 #include <wtf/NeverDestroyed.h>
  82 #include <wtf/Optional.h>
  83 #include <wtf/Ref.h>
  84 #include <wtf/RefPtr.h>
  85 #include <wtf/Variant.h>
  86 #include <wtf/Vector.h>
  87 #include <wtf/text/WTFString.h>
  88
  89 namespace WebCore {
  90
  91 WTF_MAKE_ISO_ALLOCATED_IMPL(WebGPUDevice);
  92
  93 RefPtr<WebGPUDevice> WebGPUDevice::tryCreate(ScriptExecutionContext& context, Ref<const WebGPUAdapter>&& adapter)
  94 {
  95     if (auto device = GPUDevice::tryCreate(adapter->options()))
  96         return adoptRef(new WebGPUDevice(context, WTFMove(adapter), device.releaseNonNull()));
  97     return nullptr;
  98 }
  99
 100 HashSet<WebGPUDevice*>& WebGPUDevice::instances(const LockHolder&)
 101 {
 102     static NeverDestroyed<HashSet<WebGPUDevice*>> instances;
 103     return instances;
 104 }
 105
 106 Lock& WebGPUDevice::instancesMutex()
 107 {
 108     static LazyNeverDestroyed<Lock> mutex;
 109     static std::once_flag initializeMutex;
 110     std::call_once(initializeMutex, [] {
 111         mutex.construct();
 112     });
 113     return mutex.get();
 114 }
 115
 116 WebGPUDevice::WebGPUDevice(ScriptExecutionContext& context, Ref<const WebGPUAdapter>&& adapter, Ref<GPUDevice>&& device)
 117     : m_scriptExecutionContext(context)
 118     , m_adapter(WTFMove(adapter))
 119     , m_device(WTFMove(device))
 120     , m_errorScopes(GPUErrorScopes::create([this, weakThis = makeWeakPtr(this)] (GPUError&& error) {
 121         if (weakThis)
 122             dispatchUncapturedError(WTFMove(error));
 123     }))
 124 {
 125     ASSERT(m_scriptExecutionContext.isDocument());
 126
 127     LockHolder lock(instancesMutex());
 128     instances(lock).add(this);
 129 }
 130
 131 WebGPUDevice::~WebGPUDevice()
 132 {
 133     InspectorInstrumentation::willDestroyWebGPUDevice(*this);
 134
 135     LockHolder lock(instancesMutex());
 136     ASSERT(instances(lock).contains(this));
 137     instances(lock).remove(this);
 138 }
 139
 140 Ref<WebGPUBuffer> WebGPUDevice::createBuffer(const GPUBufferDescriptor& descriptor) const
 141 {
 142     m_errorScopes->setErrorPrefix("GPUDevice.createBuffer(): ");
 143
 144     auto buffer = m_device->tryCreateBuffer(descriptor, GPUBufferMappedOption::NotMapped, m_errorScopes);
 145     return WebGPUBuffer::create(WTFMove(buffer), m_errorScopes);
 146 }
 147
 148 Vector<JSC::JSValue> WebGPUDevice::createBufferMapped(JSC::ExecState& state, const GPUBufferDescriptor& descriptor) const
 149 {
 150     m_errorScopes->setErrorPrefix("GPUDevice.createBufferMapped(): ");
 151
 152     JSC::JSValue wrappedArrayBuffer = JSC::jsNull();
 153
 154     auto buffer = m_device->tryCreateBuffer(descriptor, GPUBufferMappedOption::IsMapped, m_errorScopes);
 155     if (buffer) {
 156         auto arrayBuffer = buffer->mapOnCreation();
 157         wrappedArrayBuffer = toJS(&state, JSC::jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject()), arrayBuffer);
 158     }
 159
 160     auto webBuffer = WebGPUBuffer::create(WTFMove(buffer), m_errorScopes);
 161     auto wrappedWebBuffer = toJS(&state, JSC::jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject()), webBuffer);
 162
 163     return { wrappedWebBuffer, wrappedArrayBuffer };
 164 }
 165
 166 Ref<WebGPUTexture> WebGPUDevice::createTexture(const GPUTextureDescriptor& descriptor) const
 167 {
 168     auto texture = m_device->tryCreateTexture(descriptor);
 169     return WebGPUTexture::create(WTFMove(texture));
 170 }
 171
 172 Ref<WebGPUSampler> WebGPUDevice::createSampler(const GPUSamplerDescriptor& descriptor) const
 173 {
 174     auto sampler = m_device->tryCreateSampler(descriptor);
 175     return WebGPUSampler::create(WTFMove(sampler));
 176 }
 177
 178 Ref<WebGPUBindGroupLayout> WebGPUDevice::createBindGroupLayout(const GPUBindGroupLayoutDescriptor& descriptor) const
 179 {
 180     auto layout = m_device->tryCreateBindGroupLayout(descriptor);
 181     return WebGPUBindGroupLayout::create(WTFMove(layout));
 182 }
 183
 184 Ref<WebGPUPipelineLayout> WebGPUDevice::createPipelineLayout(const WebGPUPipelineLayoutDescriptor& descriptor) const
 185 {
 186     auto gpuDescriptor = descriptor.tryCreateGPUPipelineLayoutDescriptor();
 187     if (!gpuDescriptor)
 188         return WebGPUPipelineLayout::create(nullptr);
 189
 190     auto layout = m_device->createPipelineLayout(WTFMove(*gpuDescriptor));
 191     return WebGPUPipelineLayout::create(WTFMove(layout));
 192 }
 193
 194 Ref<WebGPUBindGroup> WebGPUDevice::createBindGroup(const WebGPUBindGroupDescriptor& descriptor) const
 195 {
 196     auto gpuDescriptor = descriptor.tryCreateGPUBindGroupDescriptor();
 197     if (!gpuDescriptor)
 198         return WebGPUBindGroup::create(nullptr);
 199
 200     auto bindGroup = m_device->tryCreateBindGroup(*gpuDescriptor, m_errorScopes);
 201     return WebGPUBindGroup::create(WTFMove(bindGroup));
 202 }
 203
 204 Ref<WebGPUShaderModule> WebGPUDevice::createShaderModule(const WebGPUShaderModuleDescriptor& descriptor) const
 205 {
 206     // FIXME: What can be validated here?
 207     auto module = m_device->tryCreateShaderModule(GPUShaderModuleDescriptor { descriptor.code });
 208     return WebGPUShaderModule::create(WTFMove(module));
 209 }
 210
 211 Ref<WebGPURenderPipeline> WebGPUDevice::createRenderPipeline(const WebGPURenderPipelineDescriptor& descriptor) const
 212 {
 213     m_errorScopes->setErrorPrefix("GPUDevice.createRenderPipeline(): ");
 214
 215     auto gpuDescriptor = descriptor.tryCreateGPURenderPipelineDescriptor(m_errorScopes);
 216     if (!gpuDescriptor)
 217         return WebGPURenderPipeline::create(nullptr, m_errorScopes);
 218
 219     auto pipeline = m_device->tryCreateRenderPipeline(*gpuDescriptor, m_errorScopes);
 220     return WebGPURenderPipeline::create(WTFMove(pipeline), m_errorScopes);
 221 }
 222
 223 Ref<WebGPUComputePipeline> WebGPUDevice::createComputePipeline(const WebGPUComputePipelineDescriptor& descriptor) const
 224 {
 225     m_errorScopes->setErrorPrefix("GPUDevice.createComputePipeline(): ");
 226
 227     auto gpuDescriptor = descriptor.tryCreateGPUComputePipelineDescriptor(m_errorScopes);
 228     if (!gpuDescriptor)
 229         return WebGPUComputePipeline::create(nullptr, m_errorScopes);
 230
 231     auto pipeline = m_device->tryCreateComputePipeline(*gpuDescriptor, m_errorScopes);
 232     return WebGPUComputePipeline::create(WTFMove(pipeline), m_errorScopes);
 233 }
 234
 235 Ref<WebGPUCommandEncoder> WebGPUDevice::createCommandEncoder() const
 236 {
 237     auto commandBuffer = m_device->tryCreateCommandBuffer();
 238     return WebGPUCommandEncoder::create(WTFMove(commandBuffer));
 239 }
 240
 241 Ref<WebGPUQueue> WebGPUDevice::getQueue() const
 242 {
 243     if (!m_queue)
 244         m_queue = WebGPUQueue::create(m_device->tryGetQueue());
 245
 246     return makeRef(*m_queue.get());
 247 }
 248
 249 void WebGPUDevice::popErrorScope(ErrorPromise&& promise)
 250 {
 251     String failMessage;
 252     Optional<GPUError> error = m_errorScopes->popErrorScope(failMessage);
 253     if (failMessage.isEmpty())
 254         promise.resolve(error);
 255     else
 256         promise.reject(Exception { OperationError, "GPUDevice::popErrorScope(): " + failMessage });
 257 }
 258
 259 // Errors reported via the validation error event should also appear in the console as warnings.
 260 static void printValidationErrorToConsole(GPUError& error, ScriptExecutionContext& context)
 261 {
 262     if (!WTF::holds_alternative<RefPtr<GPUValidationError>>(error))
 263         return;
 264
 265     auto validationError = WTF::get<RefPtr<GPUValidationError>>(error);
 266     if (!validationError)
 267         return;
 268
 269     auto message = validationError->message();
 270     auto consoleMessage = makeUnique<Inspector::ConsoleMessage>(MessageSource::Rendering, MessageType::Log, MessageLevel::Warning, message);
 271
 272     downcast<Document>(context).addConsoleMessage(WTFMove(consoleMessage));
 273 }
 274
 275 void WebGPUDevice::dispatchUncapturedError(GPUError&& error)
 276 {
 277     printValidationErrorToConsole(error, m_scriptExecutionContext);
 278
 279     callOnMainThread([error = WTFMove(error), this, protectedThis = makeRef(*this)] () mutable {
 280         dispatchEvent(GPUUncapturedErrorEvent::create(eventNames().uncapturederrorEvent, WTFMove(error)));
 281     });
 282 }
 283
 284 } // namespace WebCore
 285
 286 #endif // ENABLE(WEBGPU)