dom/webgpu/Buffer.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/WebGPUBinding.h"
   7 #include "Buffer.h"
   8
   9 #include "mozilla/dom/Promise.h"
  10 #include "mozilla/dom/ScriptSettings.h"
  11 #include "mozilla/HoldDropJSObjects.h"
  12 #include "mozilla/ipc/Shmem.h"
  13 #include "ipc/WebGPUChild.h"
  14 #include "js/ArrayBuffer.h"
  15 #include "js/RootingAPI.h"
  16 #include "nsContentUtils.h"
  17 #include "nsWrapperCache.h"
  18 #include "Device.h"
  19
  20 namespace mozilla::webgpu {
  21
  22 GPU_IMPL_JS_WRAP(Buffer)
  23
  24 NS_IMPL_CYCLE_COLLECTION_CLASS(Buffer)
  25 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Buffer)
  26   tmp->Drop();
  27   NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
  28   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  29 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  30 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Buffer)
  31   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
  32 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  33 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Buffer)
  34   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
  35   if (tmp->mMapped) {
  36     for (uint32_t i = 0; i < tmp->mMapped->mArrayBuffers.Length(); ++i) {
  37       NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(
  38           mMapped->mArrayBuffers[i])
  39     }
  40   }
  41 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  42
  43 Buffer::Buffer(Device* const aParent, RawId aId, BufferAddress aSize,
  44                uint32_t aUsage, ipc::WritableSharedMemoryMapping&& aShmem)
  45     : ChildOf(aParent), mId(aId), mSize(aSize), mUsage(aUsage) {
  46   mozilla::HoldJSObjects(this);
  47   mShmem =
  48       std::make_shared<ipc::WritableSharedMemoryMapping>(std::move(aShmem));
  49   MOZ_ASSERT(mParent);
  50 }
  51
  52 Buffer::~Buffer() {
  53   Drop();
  54   mozilla::DropJSObjects(this);
  55 }
  56
  57 already_AddRefed<Buffer> Buffer::Create(Device* aDevice, RawId aDeviceId,
  58                                         const dom::GPUBufferDescriptor& aDesc,
  59                                         ErrorResult& aRv) {
  60   if (aDevice->IsLost()) {
  61     RefPtr<Buffer> buffer = new Buffer(aDevice, 0, aDesc.mSize, 0,
  62                                        ipc::WritableSharedMemoryMapping());
  63     return buffer.forget();
  64   }
  65
  66   RefPtr<WebGPUChild> actor = aDevice->GetBridge();
  67
  68   auto handle = ipc::UnsafeSharedMemoryHandle();
  69   auto mapping = ipc::WritableSharedMemoryMapping();
  70
  71   bool hasMapFlags = aDesc.mUsage & (dom::GPUBufferUsage_Binding::MAP_WRITE |
  72                                      dom::GPUBufferUsage_Binding::MAP_READ);
  73   if (hasMapFlags || aDesc.mMappedAtCreation) {
  74     const auto checked = CheckedInt<size_t>(aDesc.mSize);
  75     if (!checked.isValid()) {
  76       aRv.ThrowRangeError("Mappable size is too large");
  77       return nullptr;
  78     }
  79     size_t size = checked.value();
  80
  81     auto maybeShmem = ipc::UnsafeSharedMemoryHandle::CreateAndMap(size);
  82
  83     if (maybeShmem.isNothing()) {
  84       aRv.ThrowRangeError(
  85           nsPrintfCString("Unable to allocate shmem of size %" PRIuPTR, size));
  86       return nullptr;
  87     }
  88
  89     handle = std::move(maybeShmem.ref().first);
  90     mapping = std::move(maybeShmem.ref().second);
  91
  92     MOZ_RELEASE_ASSERT(mapping.Size() >= size);
  93
  94     // zero out memory
  95     memset(mapping.Bytes().data(), 0, size);
  96   }
  97
  98   RawId id = actor->DeviceCreateBuffer(aDeviceId, aDesc, std::move(handle));
  99
 100   RefPtr<Buffer> buffer =
 101       new Buffer(aDevice, id, aDesc.mSize, aDesc.mUsage, std::move(mapping));
 102   if (aDesc.mMappedAtCreation) {
 103     // Mapped at creation's raison d'être is write access, since the buffer is
 104     // being created and there isn't anything interesting to read in it yet.
 105     bool writable = true;
 106     buffer->SetMapped(0, aDesc.mSize, writable);
 107   }
 108
 109   return buffer.forget();
 110 }
 111
 112 void Buffer::Drop() {
 113   AbortMapRequest();
 114
 115   if (mMapped && !mMapped->mArrayBuffers.IsEmpty()) {
 116     // The array buffers could live longer than us and our shmem, so make sure
 117     // we clear the external buffer bindings.
 118     dom::AutoJSAPI jsapi;
 119     if (jsapi.Init(GetDevice().GetOwnerGlobal())) {
 120       IgnoredErrorResult rv;
 121       UnmapArrayBuffers(jsapi.cx(), rv);
 122     }
 123   }
 124   mMapped.reset();
 125
 126   if (mValid && !GetDevice().IsLost()) {
 127     GetDevice().GetBridge()->SendBufferDrop(mId);
 128   }
 129   mValid = false;
 130 }
 131
 132 void Buffer::SetMapped(BufferAddress aOffset, BufferAddress aSize,
 133                        bool aWritable) {
 134   MOZ_ASSERT(!mMapped);
 135   MOZ_RELEASE_ASSERT(aOffset <= mSize);
 136   MOZ_RELEASE_ASSERT(aSize <= mSize - aOffset);
 137
 138   mMapped.emplace();
 139   mMapped->mWritable = aWritable;
 140   mMapped->mOffset = aOffset;
 141   mMapped->mSize = aSize;
 142 }
 143
 144 already_AddRefed<dom::Promise> Buffer::MapAsync(
 145     uint32_t aMode, uint64_t aOffset, const dom::Optional<uint64_t>& aSize,
 146     ErrorResult& aRv) {
 147   RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
 148   if (NS_WARN_IF(aRv.Failed())) {
 149     return nullptr;
 150   }
 151
 152   if (GetDevice().IsLost()) {
 153     promise->MaybeRejectWithOperationError("Device Lost");
 154     return promise.forget();
 155   }
 156
 157   if (mMapRequest) {
 158     promise->MaybeRejectWithOperationError("Buffer mapping is already pending");
 159     return promise.forget();
 160   }
 161
 162   BufferAddress size = 0;
 163   if (aSize.WasPassed()) {
 164     size = aSize.Value();
 165   } else if (aOffset <= mSize) {
 166     // Default to passing the reminder of the buffer after the provided offset.
 167     size = mSize - aOffset;
 168   } else {
 169     // The provided offset is larger than the buffer size.
 170     // The parent side will handle the error, we can let the requested size be
 171     // zero.
 172   }
 173
 174   RefPtr<Buffer> self(this);
 175
 176   auto mappingPromise =
 177       GetDevice().GetBridge()->SendBufferMap(mId, aMode, aOffset, size);
 178   MOZ_ASSERT(mappingPromise);
 179
 180   mMapRequest = promise;
 181
 182   mappingPromise->Then(
 183       GetCurrentSerialEventTarget(), __func__,
 184       [promise, self](BufferMapResult&& aResult) {
 185         // Unmap might have been called while the result was on the way back.
 186         if (promise->State() != dom::Promise::PromiseState::Pending) {
 187           return;
 188         }
 189
 190         switch (aResult.type()) {
 191           case BufferMapResult::TBufferMapSuccess: {
 192             auto& success = aResult.get_BufferMapSuccess();
 193             self->mMapRequest = nullptr;
 194             self->SetMapped(success.offset(), success.size(),
 195                             success.writable());
 196             promise->MaybeResolve(0);
 197             break;
 198           }
 199           case BufferMapResult::TBufferMapError: {
 200             auto& error = aResult.get_BufferMapError();
 201             self->RejectMapRequest(promise, error.message());
 202             break;
 203           }
 204           default: {
 205             MOZ_CRASH("unreachable");
 206           }
 207         }
 208       },
 209       [promise](const ipc::ResponseRejectReason&) {
 210         promise->MaybeRejectWithAbortError("Internal communication error!");
 211       });
 212
 213   return promise.forget();
 214 }
 215
 216 static void ExternalBufferFreeCallback(void* aContents, void* aUserData) {
 217   Unused << aContents;
 218   auto shm = static_cast<std::shared_ptr<ipc::WritableSharedMemoryMapping>*>(
 219       aUserData);
 220   delete shm;
 221 }
 222
 223 void Buffer::GetMappedRange(JSContext* aCx, uint64_t aOffset,
 224                             const dom::Optional<uint64_t>& aSize,
 225                             JS::Rooted<JSObject*>* aObject, ErrorResult& aRv) {
 226   if (!mMapped) {
 227     aRv.ThrowInvalidStateError("Buffer is not mapped");
 228     return;
 229   }
 230
 231   const auto checkedOffset = CheckedInt<size_t>(aOffset);
 232   const auto checkedSize = aSize.WasPassed()
 233                                ? CheckedInt<size_t>(aSize.Value())
 234                                : CheckedInt<size_t>(mSize) - aOffset;
 235   const auto checkedMinBufferSize = checkedOffset + checkedSize;
 236
 237   if (!checkedOffset.isValid() || !checkedSize.isValid() ||
 238       !checkedMinBufferSize.isValid() || aOffset < mMapped->mOffset ||
 239       checkedMinBufferSize.value() > mMapped->mOffset + mMapped->mSize) {
 240     aRv.ThrowRangeError("Invalid range");
 241     return;
 242   }
 243
 244   auto offset = checkedOffset.value();
 245   auto size = checkedSize.value();
 246   auto span = mShmem->Bytes().Subspan(offset, size);
 247
 248   std::shared_ptr<ipc::WritableSharedMemoryMapping>* userData =
 249       new std::shared_ptr<ipc::WritableSharedMemoryMapping>(mShmem);
 250   UniquePtr<void, JS::BufferContentsDeleter> dataPtr{
 251       span.data(), {&ExternalBufferFreeCallback, userData}};
 252   JS::Rooted<JSObject*> arrayBuffer(
 253       aCx, JS::NewExternalArrayBuffer(aCx, size, std::move(dataPtr)));
 254   if (!arrayBuffer) {
 255     aRv.NoteJSContextException(aCx);
 256     return;
 257   }
 258
 259   aObject->set(arrayBuffer);
 260   mMapped->mArrayBuffers.AppendElement(*aObject);
 261 }
 262
 263 void Buffer::UnmapArrayBuffers(JSContext* aCx, ErrorResult& aRv) {
 264   MOZ_ASSERT(mMapped);
 265
 266   bool detachedArrayBuffers = true;
 267   for (const auto& arrayBuffer : mMapped->mArrayBuffers) {
 268     JS::Rooted<JSObject*> rooted(aCx, arrayBuffer);
 269     if (!JS::DetachArrayBuffer(aCx, rooted)) {
 270       detachedArrayBuffers = false;
 271     }
 272   };
 273
 274   mMapped->mArrayBuffers.Clear();
 275
 276   AbortMapRequest();
 277
 278   if (NS_WARN_IF(!detachedArrayBuffers)) {
 279     aRv.NoteJSContextException(aCx);
 280     return;
 281   }
 282 }
 283
 284 void Buffer::RejectMapRequest(dom::Promise* aPromise, nsACString& message) {
 285   if (mMapRequest == aPromise) {
 286     mMapRequest = nullptr;
 287   }
 288
 289   aPromise->MaybeRejectWithOperationError(message);
 290 }
 291
 292 void Buffer::AbortMapRequest() {
 293   if (mMapRequest) {
 294     mMapRequest->MaybeRejectWithAbortError("Buffer unmapped");
 295   }
 296   mMapRequest = nullptr;
 297 }
 298
 299 void Buffer::Unmap(JSContext* aCx, ErrorResult& aRv) {
 300   if (!mMapped) {
 301     return;
 302   }
 303
 304   UnmapArrayBuffers(aCx, aRv);
 305
 306   bool hasMapFlags = mUsage & (dom::GPUBufferUsage_Binding::MAP_WRITE |
 307                                dom::GPUBufferUsage_Binding::MAP_READ);
 308
 309   if (!hasMapFlags) {
 310     // We get here if the buffer was mapped at creation without map flags.
 311     // It won't be possible to map the buffer again so we can get rid of
 312     // our shmem on this side.
 313     mShmem = std::make_shared<ipc::WritableSharedMemoryMapping>();
 314   }
 315
 316   if (!GetDevice().IsLost()) {
 317     GetDevice().GetBridge()->SendBufferUnmap(GetDevice().mId, mId,
 318                                              mMapped->mWritable);
 319   }
 320
 321   mMapped.reset();
 322 }
 323
 324 void Buffer::Destroy(JSContext* aCx, ErrorResult& aRv) {
 325   if (mMapped) {
 326     Unmap(aCx, aRv);
 327   }
 328
 329   if (!GetDevice().IsLost()) {
 330     GetDevice().GetBridge()->SendBufferDestroy(mId);
 331   }
 332   // TODO: we don't have to implement it right now, but it's used by the
 333   // examples
 334 }
 335
 336 dom::GPUBufferMapState Buffer::MapState() const {
 337   // Implementation reference:
 338   // <https://gpuweb.github.io/gpuweb/#dom-gpubuffer-mapstate>.
 339
 340   if (mMapped) {
 341     return dom::GPUBufferMapState::Mapped;
 342   }
 343   if (mMapRequest) {
 344     return dom::GPUBufferMapState::Pending;
 345   }
 346   return dom::GPUBufferMapState::Unmapped;
 347 }
 348
 349 }  // namespace mozilla::webgpu