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       // This feature is not fully implemented upstream.
 122       return Nothing();  // Some(WGPUFeatures_SHADER_F16);
 123
 124     case dom::GPUFeatureName::Rg11b10ufloat_renderable:
 125       return Some(WGPUFeatures_RG11B10UFLOAT_RENDERABLE);
 126
 127     case dom::GPUFeatureName::Bgra8unorm_storage:
 128       return Some(WGPUFeatures_BGRA8UNORM_STORAGE);
 129
 130     case dom::GPUFeatureName::Float32_filterable:
 131       return Some(WGPUFeatures_FLOAT32_FILTERABLE);
 132   }
 133   MOZ_CRASH("Bad GPUFeatureName.");
 134 }
 135
 136 static Maybe<ffi::WGPUFeatures> MakeFeatureBits(
 137     const dom::Sequence<dom::GPUFeatureName>& aFeatures) {
 138   ffi::WGPUFeatures bits = 0;
 139   for (const auto& feature : aFeatures) {
 140     const auto bit = ToWGPUFeatures(feature);
 141     if (!bit) {
 142       const auto featureStr = dom::GetEnumString(feature);
 143       (void)featureStr;
 144       NS_WARNING(
 145           nsPrintfCString("Requested feature bit for '%s' is not implemented.",
 146                           featureStr.get())
 147               .get());
 148       return Nothing();
 149     }
 150     bits |= *bit;
 151   }
 152   return Some(bits);
 153 }
 154
 155 Adapter::Adapter(Instance* const aParent, WebGPUChild* const aBridge,
 156                  const std::shared_ptr<ffi::WGPUAdapterInformation>& aInfo)
 157     : ChildOf(aParent),
 158       mBridge(aBridge),
 159       mId(aInfo->id),
 160       mFeatures(new SupportedFeatures(this)),
 161       mLimits(new SupportedLimits(this, aInfo->limits)),
 162       mInfo(aInfo) {
 163   ErrorResult ignoredRv;  // It's onerous to plumb this in from outside in this
 164                           // case, and we don't really need to.
 165
 166   static const auto FEATURE_BY_BIT = []() {
 167     auto ret = std::unordered_map<ffi::WGPUFeatures, dom::GPUFeatureName>{};
 168
 169     for (const auto feature :
 170          dom::MakeWebIDLEnumeratedRange<dom::GPUFeatureName>()) {
 171       const auto bitForFeature = ToWGPUFeatures(feature);
 172       if (!bitForFeature) {
 173         // There are some features that don't have bits.
 174         continue;
 175       }
 176       ret[*bitForFeature] = feature;
 177     }
 178
 179     return ret;
 180   }();
 181
 182   auto remainingFeatureBits = aInfo->features;
 183   auto bitMask = decltype(remainingFeatureBits){0};
 184   while (remainingFeatureBits) {
 185     if (bitMask) {
 186       bitMask <<= 1;
 187     } else {
 188       bitMask = 1;
 189     }
 190     const auto bit = remainingFeatureBits & bitMask;
 191     remainingFeatureBits &= ~bitMask;  // Clear bit.
 192     if (!bit) {
 193       continue;
 194     }
 195
 196     const auto featureForBit = FEATURE_BY_BIT.find(bit);
 197     if (featureForBit != FEATURE_BY_BIT.end()) {
 198       mFeatures->Add(featureForBit->second, ignoredRv);
 199     } else {
 200       // We don't recognize that bit, but maybe it's a wpgu-native-only feature.
 201     }
 202   }
 203 }
 204
 205 Adapter::~Adapter() { Cleanup(); }
 206
 207 void Adapter::Cleanup() {
 208   if (mValid && mBridge && mBridge->CanSend()) {
 209     mValid = false;
 210     mBridge->SendAdapterDrop(mId);
 211   }
 212 }
 213
 214 const RefPtr<SupportedFeatures>& Adapter::Features() const { return mFeatures; }
 215 const RefPtr<SupportedLimits>& Adapter::Limits() const { return mLimits; }
 216 bool Adapter::IsFallbackAdapter() const {
 217   return mInfo->device_type == ffi::WGPUDeviceType::WGPUDeviceType_Cpu;
 218 }
 219
 220 static std::string_view ToJsKey(const Limit limit) {
 221   switch (limit) {
 222     case Limit::MaxTextureDimension1D:
 223       return "maxTextureDimension1D";
 224     case Limit::MaxTextureDimension2D:
 225       return "maxTextureDimension2D";
 226     case Limit::MaxTextureDimension3D:
 227       return "maxTextureDimension3D";
 228     case Limit::MaxTextureArrayLayers:
 229       return "maxTextureArrayLayers";
 230     case Limit::MaxBindGroups:
 231       return "maxBindGroups";
 232     case Limit::MaxBindGroupsPlusVertexBuffers:
 233       return "maxBindGroupsPlusVertexBuffers";
 234     case Limit::MaxBindingsPerBindGroup:
 235       return "maxBindingsPerBindGroup";
 236     case Limit::MaxDynamicUniformBuffersPerPipelineLayout:
 237       return "maxDynamicUniformBuffersPerPipelineLayout";
 238     case Limit::MaxDynamicStorageBuffersPerPipelineLayout:
 239       return "maxDynamicStorageBuffersPerPipelineLayout";
 240     case Limit::MaxSampledTexturesPerShaderStage:
 241       return "maxSampledTexturesPerShaderStage";
 242     case Limit::MaxSamplersPerShaderStage:
 243       return "maxSamplersPerShaderStage";
 244     case Limit::MaxStorageBuffersPerShaderStage:
 245       return "maxStorageBuffersPerShaderStage";
 246     case Limit::MaxStorageTexturesPerShaderStage:
 247       return "maxStorageTexturesPerShaderStage";
 248     case Limit::MaxUniformBuffersPerShaderStage:
 249       return "maxUniformBuffersPerShaderStage";
 250     case Limit::MaxUniformBufferBindingSize:
 251       return "maxUniformBufferBindingSize";
 252     case Limit::MaxStorageBufferBindingSize:
 253       return "maxStorageBufferBindingSize";
 254     case Limit::MinUniformBufferOffsetAlignment:
 255       return "minUniformBufferOffsetAlignment";
 256     case Limit::MinStorageBufferOffsetAlignment:
 257       return "minStorageBufferOffsetAlignment";
 258     case Limit::MaxVertexBuffers:
 259       return "maxVertexBuffers";
 260     case Limit::MaxBufferSize:
 261       return "maxBufferSize";
 262     case Limit::MaxVertexAttributes:
 263       return "maxVertexAttributes";
 264     case Limit::MaxVertexBufferArrayStride:
 265       return "maxVertexBufferArrayStride";
 266     case Limit::MaxInterStageShaderComponents:
 267       return "maxInterStageShaderComponents";
 268     case Limit::MaxInterStageShaderVariables:
 269       return "maxInterStageShaderVariables";
 270     case Limit::MaxColorAttachments:
 271       return "maxColorAttachments";
 272     case Limit::MaxColorAttachmentBytesPerSample:
 273       return "maxColorAttachmentBytesPerSample";
 274     case Limit::MaxComputeWorkgroupStorageSize:
 275       return "maxComputeWorkgroupStorageSize";
 276     case Limit::MaxComputeInvocationsPerWorkgroup:
 277       return "maxComputeInvocationsPerWorkgroup";
 278     case Limit::MaxComputeWorkgroupSizeX:
 279       return "maxComputeWorkgroupSizeX";
 280     case Limit::MaxComputeWorkgroupSizeY:
 281       return "maxComputeWorkgroupSizeY";
 282     case Limit::MaxComputeWorkgroupSizeZ:
 283       return "maxComputeWorkgroupSizeZ";
 284     case Limit::MaxComputeWorkgroupsPerDimension:
 285       return "maxComputeWorkgroupsPerDimension";
 286   }
 287   MOZ_CRASH("Bad Limit");
 288 }
 289
 290 // -
 291 // String helpers
 292
 293 static auto ToACString(const nsAString& s) { return NS_ConvertUTF16toUTF8(s); }
 294
 295 // -
 296 // Adapter::RequestDevice
 297
 298 already_AddRefed<dom::Promise> Adapter::RequestDevice(
 299     const dom::GPUDeviceDescriptor& aDesc, ErrorResult& aRv) {
 300   RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
 301   if (NS_WARN_IF(aRv.Failed())) {
 302     return nullptr;
 303   }
 304
 305   ffi::WGPULimits deviceLimits = *mLimits->mFfi;
 306   for (const auto limit : MakeInclusiveEnumeratedRange(Limit::_LAST)) {
 307     const auto defaultValue = [&]() -> double {
 308       switch (limit) {
 309           // clang-format off
 310       case Limit::MaxTextureDimension1D: return 8192;
 311       case Limit::MaxTextureDimension2D: return 8192;
 312       case Limit::MaxTextureDimension3D: return 2048;
 313       case Limit::MaxTextureArrayLayers: return 256;
 314       case Limit::MaxBindGroups: return 4;
 315       case Limit::MaxBindGroupsPlusVertexBuffers: return 24;
 316       case Limit::MaxBindingsPerBindGroup: return 1000;
 317       case Limit::MaxDynamicUniformBuffersPerPipelineLayout: return 8;
 318       case Limit::MaxDynamicStorageBuffersPerPipelineLayout: return 4;
 319       case Limit::MaxSampledTexturesPerShaderStage: return 16;
 320       case Limit::MaxSamplersPerShaderStage: return 16;
 321       case Limit::MaxStorageBuffersPerShaderStage: return 8;
 322       case Limit::MaxStorageTexturesPerShaderStage: return 4;
 323       case Limit::MaxUniformBuffersPerShaderStage: return 12;
 324       case Limit::MaxUniformBufferBindingSize: return 65536;
 325       case Limit::MaxStorageBufferBindingSize: return 134217728;
 326       case Limit::MinUniformBufferOffsetAlignment: return 256;
 327       case Limit::MinStorageBufferOffsetAlignment: return 256;
 328       case Limit::MaxVertexBuffers: return 8;
 329       case Limit::MaxBufferSize: return 268435456;
 330       case Limit::MaxVertexAttributes: return 16;
 331       case Limit::MaxVertexBufferArrayStride: return 2048;
 332       case Limit::MaxInterStageShaderComponents: return 60;
 333       case Limit::MaxInterStageShaderVariables: return 16;
 334       case Limit::MaxColorAttachments: return 8;
 335       case Limit::MaxColorAttachmentBytesPerSample: return 32;
 336       case Limit::MaxComputeWorkgroupStorageSize: return 16384;
 337       case Limit::MaxComputeInvocationsPerWorkgroup: return 256;
 338       case Limit::MaxComputeWorkgroupSizeX: return 256;
 339       case Limit::MaxComputeWorkgroupSizeY: return 256;
 340       case Limit::MaxComputeWorkgroupSizeZ: return 64;
 341       case Limit::MaxComputeWorkgroupsPerDimension: return 65535;
 342           // clang-format on
 343       }
 344       MOZ_CRASH("Bad Limit");
 345     }();
 346     SetLimit(&deviceLimits, limit, defaultValue);
 347   }
 348
 349   // -
 350
 351   [&]() {  // So that we can `return;` instead of `return promise.forget();`.
 352     if (!mBridge->CanSend()) {
 353       promise->MaybeRejectWithInvalidStateError(
 354           "WebGPUChild cannot send, must recreate Adapter");
 355       return;
 356     }
 357
 358     // -
 359     // Validate Features
 360
 361     for (const auto requested : aDesc.mRequiredFeatures) {
 362       const bool supported = mFeatures->Features().count(requested);
 363       if (!supported) {
 364         const auto fstr = dom::GetEnumString(requested);
 365         const auto astr = this->LabelOrId();
 366         nsPrintfCString msg(
 367             "requestDevice: Feature '%s' requested must be supported by "
 368             "adapter %s",
 369             fstr.get(), astr.get());
 370         promise->MaybeRejectWithTypeError(msg);
 371         return;
 372       }
 373     }
 374
 375     // -
 376     // Validate Limits
 377
 378     if (aDesc.mRequiredLimits.WasPassed()) {
 379       static const auto LIMIT_BY_JS_KEY = []() {
 380         std::unordered_map<std::string_view, Limit> ret;
 381         for (const auto limit : MakeInclusiveEnumeratedRange(Limit::_LAST)) {
 382           const auto jsKeyU8 = ToJsKey(limit);
 383           ret[jsKeyU8] = limit;
 384         }
 385         return ret;
 386       }();
 387
 388       for (const auto& entry : aDesc.mRequiredLimits.Value().Entries()) {
 389         const auto& keyU16 = entry.mKey;
 390         const nsCString keyU8 = ToACString(keyU16);
 391         const auto itr = LIMIT_BY_JS_KEY.find(keyU8.get());
 392         if (itr == LIMIT_BY_JS_KEY.end()) {
 393           nsPrintfCString msg("requestDevice: Limit '%s' not recognized.",
 394                               keyU8.get());
 395           promise->MaybeRejectWithOperationError(msg);
 396           return;
 397         }
 398
 399         const auto& limit = itr->second;
 400         uint64_t requestedValue = entry.mValue;
 401         const auto supportedValue = GetLimit(*mLimits->mFfi, limit);
 402         if (StringBeginsWith(keyU8, "max"_ns)) {
 403           if (requestedValue > supportedValue) {
 404             nsPrintfCString msg(
 405                 "requestDevice: Request for limit '%s' must be <= supported "
 406                 "%s, was %s.",
 407                 keyU8.get(), std::to_string(supportedValue).c_str(),
 408                 std::to_string(requestedValue).c_str());
 409             promise->MaybeRejectWithOperationError(msg);
 410             return;
 411           }
 412           // Clamp to default if lower than default
 413           requestedValue =
 414               std::max(requestedValue, GetLimit(deviceLimits, limit));
 415         } else {
 416           MOZ_ASSERT(StringBeginsWith(keyU8, "min"_ns));
 417           if (requestedValue < supportedValue) {
 418             nsPrintfCString msg(
 419                 "requestDevice: Request for limit '%s' must be >= supported "
 420                 "%s, was %s.",
 421                 keyU8.get(), std::to_string(supportedValue).c_str(),
 422                 std::to_string(requestedValue).c_str());
 423             promise->MaybeRejectWithOperationError(msg);
 424             return;
 425           }
 426           if (StringEndsWith(keyU8, "Alignment"_ns)) {
 427             if (!IsPowerOfTwo(requestedValue)) {
 428               nsPrintfCString msg(
 429                   "requestDevice: Request for limit '%s' must be a power of "
 430                   "two, "
 431                   "was %s.",
 432                   keyU8.get(), std::to_string(requestedValue).c_str());
 433               promise->MaybeRejectWithOperationError(msg);
 434               return;
 435             }
 436           }
 437           /// Clamp to default if higher than default
 438           requestedValue =
 439               std::min(requestedValue, GetLimit(deviceLimits, limit));
 440         }
 441
 442         SetLimit(&deviceLimits, limit, requestedValue);
 443       }
 444     }
 445
 446     // -
 447
 448     ffi::WGPUFfiDeviceDescriptor ffiDesc = {};
 449     ffiDesc.required_features = *MakeFeatureBits(aDesc.mRequiredFeatures);
 450     ffiDesc.required_limits = deviceLimits;
 451     auto request = mBridge->AdapterRequestDevice(mId, ffiDesc);
 452     if (!request) {
 453       promise->MaybeRejectWithNotSupportedError(
 454           "Unable to instantiate a Device");
 455       return;
 456     }
 457     RefPtr<Device> device =
 458         new Device(this, request->mId, ffiDesc.required_limits);
 459     for (const auto& feature : aDesc.mRequiredFeatures) {
 460       device->mFeatures->Add(feature, aRv);
 461     }
 462
 463     request->mPromise->Then(
 464         GetCurrentSerialEventTarget(), __func__,
 465         [promise, device](bool aSuccess) {
 466           if (aSuccess) {
 467             promise->MaybeResolve(device);
 468           } else {
 469             // In this path, request->mId has an error entry in the wgpu
 470             // registry, so let Device::~Device clean things up on both the
 471             // child and parent side.
 472             promise->MaybeRejectWithInvalidStateError(
 473                 "Unable to fulfill requested features and limits");
 474           }
 475         },
 476         [promise, device](const ipc::ResponseRejectReason& aReason) {
 477           // We can't be sure how far along the WebGPUParent got in handling
 478           // our AdapterRequestDevice message, but we can't communicate with it,
 479           // so clear up our client state for this Device without trying to
 480           // communicate with the parent about it.
 481           device->CleanupUnregisteredInParent();
 482           promise->MaybeRejectWithNotSupportedError("IPC error");
 483         });
 484   }();
 485
 486   return promise.forget();
 487 }
 488
 489 // -
 490
 491 already_AddRefed<dom::Promise> Adapter::RequestAdapterInfo(
 492     const dom::Sequence<nsString>& /*aUnmaskHints*/, ErrorResult& aRv) const {
 493   RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
 494   if (!promise) return nullptr;
 495
 496   auto rai = UniquePtr<AdapterInfo>{new AdapterInfo(mInfo)};
 497   promise->MaybeResolve(std::move(rai));
 498   return promise.forget();
 499 }
 500
 501 }  // namespace mozilla::webgpu