dom/webgpu/Adapter.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/BindingDeclarations.h"
   7 #include "mozilla/dom/WebGPUBinding.h"
   8 #include "Adapter.h"
   9
  10 #include <algorithm>
  11 #include "Device.h"
  12 #include "Instance.h"
  13 #include "SupportedFeatures.h"
  14 #include "SupportedLimits.h"
  15 #include "ipc/WebGPUChild.h"
  16 #include "mozilla/dom/Promise.h"
  17 #include "mozilla/webgpu/ffi/wgpu.h"
  18
  19 namespace mozilla::webgpu {
  20
  21 bool AdapterInfo::WrapObject(JSContext* const cx,
  22                              JS::Handle<JSObject*> givenProto,
  23                              JS::MutableHandle<JSObject*> reflector) {
  24   return dom::GPUAdapterInfo_Binding::Wrap(cx, this, givenProto, reflector);
  25 }
  26
  27 void AdapterInfo::GetWgpuName(nsString& s) const {
  28   s = mAboutSupportInfo->name;
  29 }
  30
  31 uint32_t AdapterInfo::WgpuVendor() const { return mAboutSupportInfo->vendor; }
  32
  33 uint32_t AdapterInfo::WgpuDevice() const { return mAboutSupportInfo->device; }
  34
  35 void AdapterInfo::GetWgpuDeviceType(nsString& s) const {
  36   switch (mAboutSupportInfo->device_type) {
  37     case ffi::WGPUDeviceType_Cpu:
  38       s.AssignLiteral("Cpu");
  39       return;
  40     case ffi::WGPUDeviceType_DiscreteGpu:
  41       s.AssignLiteral("DiscreteGpu");
  42       return;
  43     case ffi::WGPUDeviceType_IntegratedGpu:
  44       s.AssignLiteral("IntegratedGpu");
  45       return;
  46     case ffi::WGPUDeviceType_VirtualGpu:
  47       s.AssignLiteral("VirtualGpu");
  48       return;
  49     case ffi::WGPUDeviceType_Other:
  50       s.AssignLiteral("Other");
  51       return;
  52     case ffi::WGPUDeviceType_Sentinel:
  53       break;
  54   }
  55   MOZ_CRASH("Bad `ffi::WGPUDeviceType`");
  56 }
  57
  58 void AdapterInfo::GetWgpuDriver(nsString& s) const {
  59   s = mAboutSupportInfo->driver;
  60 }
  61
  62 void AdapterInfo::GetWgpuDriverInfo(nsString& s) const {
  63   s = mAboutSupportInfo->driver_info;
  64 }
  65
  66 void AdapterInfo::GetWgpuBackend(nsString& s) const {
  67   switch (mAboutSupportInfo->backend) {
  68     case ffi::WGPUBackend_Empty:
  69       s.AssignLiteral("Empty");
  70       return;
  71     case ffi::WGPUBackend_Vulkan:
  72       s.AssignLiteral("Vulkan");
  73       return;
  74     case ffi::WGPUBackend_Metal:
  75       s.AssignLiteral("Metal");
  76       return;
  77     case ffi::WGPUBackend_Dx12:
  78       s.AssignLiteral("Dx12");
  79       return;
  80     case ffi::WGPUBackend_Gl:
  81       s.AssignLiteral("Gl");
  82       return;
  83     case ffi::WGPUBackend_BrowserWebGpu:  // This should never happen, because
  84                                           // we _are_ the browser.
  85     case ffi::WGPUBackend_Sentinel:
  86       break;
  87   }
  88   MOZ_CRASH("Bad `ffi::WGPUBackend`");
  89 }
  90
  91 // -
  92
  93 GPU_IMPL_CYCLE_COLLECTION(Adapter, mParent, mBridge, mFeatures, mLimits)
  94 GPU_IMPL_JS_WRAP(Adapter)
  95
  96 static Maybe<ffi::WGPUFeatures> ToWGPUFeatures(
  97     const dom::GPUFeatureName aFeature) {
  98   switch (aFeature) {
  99     case dom::GPUFeatureName::Depth_clip_control:
 100       return Some(WGPUFeatures_DEPTH_CLIP_CONTROL);
 101
 102     case dom::GPUFeatureName::Depth32float_stencil8:
 103       return Some(WGPUFeatures_DEPTH32FLOAT_STENCIL8);
 104
 105     case dom::GPUFeatureName::Texture_compression_bc:
 106       return Some(WGPUFeatures_TEXTURE_COMPRESSION_BC);
 107
 108     case dom::GPUFeatureName::Texture_compression_etc2:
 109       return Some(WGPUFeatures_TEXTURE_COMPRESSION_ETC2);
 110
 111     case dom::GPUFeatureName::Texture_compression_astc:
 112       return Some(WGPUFeatures_TEXTURE_COMPRESSION_ASTC);
 113
 114     case dom::GPUFeatureName::Timestamp_query:
 115       return Some(WGPUFeatures_TIMESTAMP_QUERY);
 116
 117     case dom::GPUFeatureName::Indirect_first_instance:
 118       return Some(WGPUFeatures_INDIRECT_FIRST_INSTANCE);
 119
 120     case dom::GPUFeatureName::Shader_f16:
 121       return Some(WGPUFeatures_SHADER_F16);
 122
 123     case dom::GPUFeatureName::Rg11b10ufloat_renderable:
 124       return Some(WGPUFeatures_RG11B10UFLOAT_RENDERABLE);
 125
 126     case dom::GPUFeatureName::Bgra8unorm_storage:
 127       return Some(WGPUFeatures_BGRA8UNORM_STORAGE);
 128
 129     case dom::GPUFeatureName::Float32_filterable:
 130       return Some(WGPUFeatures_FLOAT32_FILTERABLE);
 131   }
 132   MOZ_CRASH("Bad GPUFeatureName.");
 133 }
 134
 135 static Maybe<ffi::WGPUFeatures> MakeFeatureBits(
 136     const dom::Sequence<dom::GPUFeatureName>& aFeatures) {
 137   ffi::WGPUFeatures bits = 0;
 138   for (const auto& feature : aFeatures) {
 139     const auto bit = ToWGPUFeatures(feature);
 140     if (!bit) {
 141       const auto featureStr = dom::GetEnumString(feature);
 142       (void)featureStr;
 143       NS_WARNING(
 144           nsPrintfCString("Requested feature bit for '%s' is not implemented.",
 145                           featureStr.get())
 146               .get());
 147       return Nothing();
 148     }
 149     bits |= *bit;
 150   }
 151   return Some(bits);
 152 }
 153
 154 Adapter::Adapter(Instance* const aParent, WebGPUChild* const aBridge,
 155                  const std::shared_ptr<ffi::WGPUAdapterInformation>& aInfo)
 156     : ChildOf(aParent),
 157       mBridge(aBridge),
 158       mId(aInfo->id),
 159       mFeatures(new SupportedFeatures(this)),
 160       mLimits(new SupportedLimits(this, aInfo->limits)),
 161       mInfo(aInfo) {
 162   ErrorResult ignoredRv;  // It's onerous to plumb this in from outside in this
 163                           // case, and we don't really need to.
 164
 165   static const auto FEATURE_BY_BIT = []() {
 166     auto ret = std::unordered_map<ffi::WGPUFeatures, dom::GPUFeatureName>{};
 167
 168     for (const auto feature :
 169          dom::MakeWebIDLEnumeratedRange<dom::GPUFeatureName>()) {
 170       const auto bitForFeature = ToWGPUFeatures(feature);
 171       if (!bitForFeature) {
 172         // There are some features that don't have bits.
 173         continue;
 174       }
 175       ret[*bitForFeature] = feature;
 176     }
 177
 178     return ret;
 179   }();
 180
 181   auto remainingFeatureBits = aInfo->features;
 182   auto bitMask = decltype(remainingFeatureBits){0};
 183   while (remainingFeatureBits) {
 184     if (bitMask) {
 185       bitMask <<= 1;
 186     } else {
 187       bitMask = 1;
 188     }
 189     const auto bit = remainingFeatureBits & bitMask;
 190     remainingFeatureBits &= ~bitMask;  // Clear bit.
 191     if (!bit) {
 192       continue;
 193     }
 194
 195     const auto featureForBit = FEATURE_BY_BIT.find(bit);
 196     if (featureForBit != FEATURE_BY_BIT.end()) {
 197       mFeatures->Add(featureForBit->second, ignoredRv);
 198     } else {
 199       // We don't recognize that bit, but maybe it's a wpgu-native-only feature.
 200     }
 201   }
 202 }
 203
 204 Adapter::~Adapter() { Cleanup(); }
 205
 206 void Adapter::Cleanup() {
 207   if (mValid && mBridge && mBridge->CanSend()) {
 208     mValid = false;
 209     mBridge->SendAdapterDrop(mId);
 210   }
 211 }
 212
 213 const RefPtr<SupportedFeatures>& Adapter::Features() const { return mFeatures; }
 214 const RefPtr<SupportedLimits>& Adapter::Limits() const { return mLimits; }
 215 bool Adapter::IsFallbackAdapter() const {
 216   return mInfo->device_type == ffi::WGPUDeviceType::WGPUDeviceType_Cpu;
 217 }
 218
 219 static std::string_view ToJsKey(const Limit limit) {
 220   switch (limit) {
 221     case Limit::MaxTextureDimension1D:
 222       return "maxTextureDimension1D";
 223     case Limit::MaxTextureDimension2D:
 224       return "maxTextureDimension2D";
 225     case Limit::MaxTextureDimension3D:
 226       return "maxTextureDimension3D";
 227     case Limit::MaxTextureArrayLayers:
 228       return "maxTextureArrayLayers";
 229     case Limit::MaxBindGroups:
 230       return "maxBindGroups";
 231     case Limit::MaxBindGroupsPlusVertexBuffers:
 232       return "maxBindGroupsPlusVertexBuffers";
 233     case Limit::MaxBindingsPerBindGroup:
 234       return "maxBindingsPerBindGroup";
 235     case Limit::MaxDynamicUniformBuffersPerPipelineLayout:
 236       return "maxDynamicUniformBuffersPerPipelineLayout";
 237     case Limit::MaxDynamicStorageBuffersPerPipelineLayout:
 238       return "maxDynamicStorageBuffersPerPipelineLayout";
 239     case Limit::MaxSampledTexturesPerShaderStage:
 240       return "maxSampledTexturesPerShaderStage";
 241     case Limit::MaxSamplersPerShaderStage:
 242       return "maxSamplersPerShaderStage";
 243     case Limit::MaxStorageBuffersPerShaderStage:
 244       return "maxStorageBuffersPerShaderStage";
 245     case Limit::MaxStorageTexturesPerShaderStage:
 246       return "maxStorageTexturesPerShaderStage";
 247     case Limit::MaxUniformBuffersPerShaderStage:
 248       return "maxUniformBuffersPerShaderStage";
 249     case Limit::MaxUniformBufferBindingSize:
 250       return "maxUniformBufferBindingSize";
 251     case Limit::MaxStorageBufferBindingSize:
 252       return "maxStorageBufferBindingSize";
 253     case Limit::MinUniformBufferOffsetAlignment:
 254       return "minUniformBufferOffsetAlignment";
 255     case Limit::MinStorageBufferOffsetAlignment:
 256       return "minStorageBufferOffsetAlignment";
 257     case Limit::MaxVertexBuffers:
 258       return "maxVertexBuffers";
 259     case Limit::MaxBufferSize:
 260       return "maxBufferSize";
 261     case Limit::MaxVertexAttributes:
 262       return "maxVertexAttributes";
 263     case Limit::MaxVertexBufferArrayStride:
 264       return "maxVertexBufferArrayStride";
 265     case Limit::MaxInterStageShaderComponents:
 266       return "maxInterStageShaderComponents";
 267     case Limit::MaxInterStageShaderVariables:
 268       return "maxInterStageShaderVariables";
 269     case Limit::MaxColorAttachments:
 270       return "maxColorAttachments";
 271     case Limit::MaxColorAttachmentBytesPerSample:
 272       return "maxColorAttachmentBytesPerSample";
 273     case Limit::MaxComputeWorkgroupStorageSize:
 274       return "maxComputeWorkgroupStorageSize";
 275     case Limit::MaxComputeInvocationsPerWorkgroup:
 276       return "maxComputeInvocationsPerWorkgroup";
 277     case Limit::MaxComputeWorkgroupSizeX:
 278       return "maxComputeWorkgroupSizeX";
 279     case Limit::MaxComputeWorkgroupSizeY:
 280       return "maxComputeWorkgroupSizeY";
 281     case Limit::MaxComputeWorkgroupSizeZ:
 282       return "maxComputeWorkgroupSizeZ";
 283     case Limit::MaxComputeWorkgroupsPerDimension:
 284       return "maxComputeWorkgroupsPerDimension";
 285   }
 286   MOZ_CRASH("Bad Limit");
 287 }
 288
 289 // -
 290 // String helpers
 291
 292 static auto ToACString(const nsAString& s) { return NS_ConvertUTF16toUTF8(s); }
 293
 294 // -
 295 // Adapter::RequestDevice
 296
 297 already_AddRefed<dom::Promise> Adapter::RequestDevice(
 298     const dom::GPUDeviceDescriptor& aDesc, ErrorResult& aRv) {
 299   RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
 300   if (NS_WARN_IF(aRv.Failed())) {
 301     return nullptr;
 302   }
 303
 304   ffi::WGPULimits deviceLimits = *mLimits->mFfi;
 305   for (const auto limit : MakeInclusiveEnumeratedRange(Limit::_LAST)) {
 306     const auto defaultValue = [&]() -> double {
 307       switch (limit) {
 308           // clang-format off
 309       case Limit::MaxTextureDimension1D: return 8192;
 310       case Limit::MaxTextureDimension2D: return 8192;
 311       case Limit::MaxTextureDimension3D: return 2048;
 312       case Limit::MaxTextureArrayLayers: return 256;
 313       case Limit::MaxBindGroups: return 4;
 314       case Limit::MaxBindGroupsPlusVertexBuffers: return 24;
 315       case Limit::MaxBindingsPerBindGroup: return 1000;
 316       case Limit::MaxDynamicUniformBuffersPerPipelineLayout: return 8;
 317       case Limit::MaxDynamicStorageBuffersPerPipelineLayout: return 4;
 318       case Limit::MaxSampledTexturesPerShaderStage: return 16;
 319       case Limit::MaxSamplersPerShaderStage: return 16;
 320       case Limit::MaxStorageBuffersPerShaderStage: return 8;
 321       case Limit::MaxStorageTexturesPerShaderStage: return 4;
 322       case Limit::MaxUniformBuffersPerShaderStage: return 12;
 323       case Limit::MaxUniformBufferBindingSize: return 65536;
 324       case Limit::MaxStorageBufferBindingSize: return 134217728;
 325       case Limit::MinUniformBufferOffsetAlignment: return 256;
 326       case Limit::MinStorageBufferOffsetAlignment: return 256;
 327       case Limit::MaxVertexBuffers: return 8;
 328       case Limit::MaxBufferSize: return 268435456;
 329       case Limit::MaxVertexAttributes: return 16;
 330       case Limit::MaxVertexBufferArrayStride: return 2048;
 331       case Limit::MaxInterStageShaderComponents: return 60;
 332       case Limit::MaxInterStageShaderVariables: return 16;
 333       case Limit::MaxColorAttachments: return 8;
 334       case Limit::MaxColorAttachmentBytesPerSample: return 32;
 335       case Limit::MaxComputeWorkgroupStorageSize: return 16384;
 336       case Limit::MaxComputeInvocationsPerWorkgroup: return 256;
 337       case Limit::MaxComputeWorkgroupSizeX: return 256;
 338       case Limit::MaxComputeWorkgroupSizeY: return 256;
 339       case Limit::MaxComputeWorkgroupSizeZ: return 64;
 340       case Limit::MaxComputeWorkgroupsPerDimension: return 65535;
 341           // clang-format on
 342       }
 343       MOZ_CRASH("Bad Limit");
 344     }();
 345     SetLimit(&deviceLimits, limit, defaultValue);
 346   }
 347
 348   // -
 349
 350   [&]() {  // So that we can `return;` instead of `return promise.forget();`.
 351     if (!mBridge->CanSend()) {
 352       promise->MaybeRejectWithInvalidStateError(
 353           "WebGPUChild cannot send, must recreate Adapter");
 354       return;
 355     }
 356
 357     // -
 358     // Validate Features
 359
 360     for (const auto requested : aDesc.mRequiredFeatures) {
 361       const bool supported = mFeatures->Features().count(requested);
 362       if (!supported) {
 363         const auto fstr = dom::GetEnumString(requested);
 364         const auto astr = this->LabelOrId();
 365         nsPrintfCString msg(
 366             "requestDevice: Feature '%s' requested must be supported by "
 367             "adapter %s",
 368             fstr.get(), astr.get());
 369         promise->MaybeRejectWithTypeError(msg);
 370         return;
 371       }
 372     }
 373
 374     // -
 375     // Validate Limits
 376
 377     if (aDesc.mRequiredLimits.WasPassed()) {
 378       static const auto LIMIT_BY_JS_KEY = []() {
 379         std::unordered_map<std::string_view, Limit> ret;
 380         for (const auto limit : MakeInclusiveEnumeratedRange(Limit::_LAST)) {
 381           const auto jsKeyU8 = ToJsKey(limit);
 382           ret[jsKeyU8] = limit;
 383         }
 384         return ret;
 385       }();
 386
 387       for (const auto& entry : aDesc.mRequiredLimits.Value().Entries()) {
 388         const auto& keyU16 = entry.mKey;
 389         const nsCString keyU8 = ToACString(keyU16);
 390         const auto itr = LIMIT_BY_JS_KEY.find(keyU8.get());
 391         if (itr == LIMIT_BY_JS_KEY.end()) {
 392           nsPrintfCString msg("requestDevice: Limit '%s' not recognized.",
 393                               keyU8.get());
 394           promise->MaybeRejectWithOperationError(msg);
 395           return;
 396         }
 397
 398         const auto& limit = itr->second;
 399         uint64_t requestedValue = entry.mValue;
 400         const auto supportedValue = GetLimit(*mLimits->mFfi, limit);
 401         if (StringBeginsWith(keyU8, "max"_ns)) {
 402           if (requestedValue > supportedValue) {
 403             nsPrintfCString msg(
 404                 "requestDevice: Request for limit '%s' must be <= supported "
 405                 "%s, was %s.",
 406                 keyU8.get(), std::to_string(supportedValue).c_str(),
 407                 std::to_string(requestedValue).c_str());
 408             promise->MaybeRejectWithOperationError(msg);
 409             return;
 410           }
 411           // Clamp to default if lower than default
 412           requestedValue =
 413               std::max(requestedValue, GetLimit(deviceLimits, limit));
 414         } else {
 415           MOZ_ASSERT(StringBeginsWith(keyU8, "min"_ns));
 416           if (requestedValue < supportedValue) {
 417             nsPrintfCString msg(
 418                 "requestDevice: Request for limit '%s' must be >= supported "
 419                 "%s, was %s.",
 420                 keyU8.get(), std::to_string(supportedValue).c_str(),
 421                 std::to_string(requestedValue).c_str());
 422             promise->MaybeRejectWithOperationError(msg);
 423             return;
 424           }
 425           if (StringEndsWith(keyU8, "Alignment"_ns)) {
 426             if (!IsPowerOfTwo(requestedValue)) {
 427               nsPrintfCString msg(
 428                   "requestDevice: Request for limit '%s' must be a power of "
 429                   "two, "
 430                   "was %s.",
 431                   keyU8.get(), std::to_string(requestedValue).c_str());
 432               promise->MaybeRejectWithOperationError(msg);
 433               return;
 434             }
 435           }
 436           /// Clamp to default if higher than default
 437           requestedValue =
 438               std::min(requestedValue, GetLimit(deviceLimits, limit));
 439         }
 440
 441         SetLimit(&deviceLimits, limit, requestedValue);
 442       }
 443     }
 444
 445     // -
 446
 447     ffi::WGPUDeviceDescriptor ffiDesc = {};
 448     ffiDesc.required_features = *MakeFeatureBits(aDesc.mRequiredFeatures);
 449     ffiDesc.required_limits = deviceLimits;
 450     auto request = mBridge->AdapterRequestDevice(mId, ffiDesc);
 451     if (!request) {
 452       promise->MaybeRejectWithNotSupportedError(
 453           "Unable to instantiate a Device");
 454       return;
 455     }
 456     RefPtr<Device> device =
 457         new Device(this, request->mId, ffiDesc.required_limits);
 458     for (const auto& feature : aDesc.mRequiredFeatures) {
 459       device->mFeatures->Add(feature, aRv);
 460     }
 461
 462     request->mPromise->Then(
 463         GetCurrentSerialEventTarget(), __func__,
 464         [promise, device](bool aSuccess) {
 465           if (aSuccess) {
 466             promise->MaybeResolve(device);
 467           } else {
 468             // In this path, request->mId has an error entry in the wgpu
 469             // registry, so let Device::~Device clean things up on both the
 470             // child and parent side.
 471             promise->MaybeRejectWithInvalidStateError(
 472                 "Unable to fulfill requested features and limits");
 473           }
 474         },
 475         [promise, device](const ipc::ResponseRejectReason& aReason) {
 476           // We can't be sure how far along the WebGPUParent got in handling
 477           // our AdapterRequestDevice message, but we can't communicate with it,
 478           // so clear up our client state for this Device without trying to
 479           // communicate with the parent about it.
 480           device->CleanupUnregisteredInParent();
 481           promise->MaybeRejectWithNotSupportedError("IPC error");
 482         });
 483   }();
 484
 485   return promise.forget();
 486 }
 487
 488 // -
 489
 490 already_AddRefed<dom::Promise> Adapter::RequestAdapterInfo(
 491     const dom::Sequence<nsString>& /*aUnmaskHints*/, ErrorResult& aRv) const {
 492   RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
 493   if (!promise) return nullptr;
 494
 495   auto rai = UniquePtr<AdapterInfo>{new AdapterInfo(mInfo)};
 496   promise->MaybeResolve(std::move(rai));
 497   return promise.forget();
 498 }
 499
 500 }  // namespace mozilla::webgpu