summaryrefslogtreecommitdiffstats
path: root/dom/webgpu/ipc/WebGPUParent.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/webgpu/ipc/WebGPUParent.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/webgpu/ipc/WebGPUParent.h')
-rw-r--r--dom/webgpu/ipc/WebGPUParent.h238
1 files changed, 238 insertions, 0 deletions
diff --git a/dom/webgpu/ipc/WebGPUParent.h b/dom/webgpu/ipc/WebGPUParent.h
new file mode 100644
index 0000000000..6ad539c21e
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUParent.h
@@ -0,0 +1,238 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGPU_PARENT_H_
+#define WEBGPU_PARENT_H_
+
+#include <unordered_map>
+
+#include "mozilla/WeakPtr.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "mozilla/webgpu/PWebGPUParent.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/ipc/RawShmem.h"
+#include "WebGPUTypes.h"
+#include "base/timer.h"
+
+namespace mozilla {
+
+namespace layers {
+class RemoteTextureOwnerClient;
+} // namespace layers
+
+namespace webgpu {
+
+class ErrorBuffer;
+class ExternalTexture;
+class PresentationData;
+
+// Destroy/Drop messages:
+// - Messages with "Destroy" in their name request deallocation of resources
+// owned by the
+// object and put the object in a destroyed state without deleting the object.
+// It is still safe to reffer to these objects.
+// - Messages with "Drop" in their name can be thought of as C++ destructors.
+// They completely
+// delete the object, so future attempts at accessing to these objects will
+// crash. The child process should *never* send a Drop message if it still
+// holds references to the object. An object that has been destroyed still
+// needs to be dropped when the last reference to it dies on the child
+// process.
+
+class WebGPUParent final : public PWebGPUParent, public SupportsWeakPtr {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebGPUParent, override)
+
+ public:
+ explicit WebGPUParent();
+
+ ipc::IPCResult RecvInstanceRequestAdapter(
+ const dom::GPURequestAdapterOptions& aOptions,
+ const nsTArray<RawId>& aTargetIds,
+ InstanceRequestAdapterResolver&& resolver);
+ ipc::IPCResult RecvAdapterRequestDevice(
+ RawId aAdapterId, const ipc::ByteBuf& aByteBuf, RawId aDeviceId,
+ AdapterRequestDeviceResolver&& resolver);
+ ipc::IPCResult RecvAdapterDrop(RawId aAdapterId);
+ ipc::IPCResult RecvDeviceDestroy(RawId aDeviceId);
+ ipc::IPCResult RecvDeviceDrop(RawId aDeviceId);
+ ipc::IPCResult RecvDeviceCreateBuffer(RawId aDeviceId, RawId aBufferId,
+ dom::GPUBufferDescriptor&& aDesc,
+ ipc::UnsafeSharedMemoryHandle&& aShmem);
+ ipc::IPCResult RecvBufferMap(RawId aDeviceId, RawId aBufferId, uint32_t aMode,
+ uint64_t aOffset, uint64_t size,
+ BufferMapResolver&& aResolver);
+ ipc::IPCResult RecvBufferUnmap(RawId aDeviceId, RawId aBufferId, bool aFlush);
+ ipc::IPCResult RecvBufferDestroy(RawId aBufferId);
+ ipc::IPCResult RecvBufferDrop(RawId aBufferId);
+ ipc::IPCResult RecvTextureDestroy(RawId aTextureId, RawId aDeviceId);
+ ipc::IPCResult RecvTextureDrop(RawId aTextureId);
+ ipc::IPCResult RecvTextureViewDrop(RawId aTextureViewId);
+ ipc::IPCResult RecvSamplerDrop(RawId aSamplerId);
+ ipc::IPCResult RecvCommandEncoderFinish(
+ RawId aEncoderId, RawId aDeviceId,
+ const dom::GPUCommandBufferDescriptor& aDesc);
+ ipc::IPCResult RecvCommandEncoderDrop(RawId aEncoderId);
+ ipc::IPCResult RecvCommandBufferDrop(RawId aCommandBufferId);
+ ipc::IPCResult RecvRenderBundleDrop(RawId aBundleId);
+ ipc::IPCResult RecvQueueSubmit(RawId aQueueId, RawId aDeviceId,
+ const nsTArray<RawId>& aCommandBuffers,
+ const nsTArray<RawId>& aTextureIds);
+ ipc::IPCResult RecvQueueOnSubmittedWorkDone(
+ RawId aQueueId, std::function<void(mozilla::void_t)>&& aResolver);
+ ipc::IPCResult RecvQueueWriteAction(RawId aQueueId, RawId aDeviceId,
+ const ipc::ByteBuf& aByteBuf,
+ ipc::UnsafeSharedMemoryHandle&& aShmem);
+ ipc::IPCResult RecvBindGroupLayoutDrop(RawId aBindGroupLayoutId);
+ ipc::IPCResult RecvPipelineLayoutDrop(RawId aPipelineLayoutId);
+ ipc::IPCResult RecvBindGroupDrop(RawId aBindGroupId);
+ ipc::IPCResult RecvShaderModuleDrop(RawId aModuleId);
+ ipc::IPCResult RecvComputePipelineDrop(RawId aPipelineId);
+ ipc::IPCResult RecvRenderPipelineDrop(RawId aPipelineId);
+ ipc::IPCResult RecvImplicitLayoutDrop(RawId aImplicitPlId,
+ const nsTArray<RawId>& aImplicitBglIds);
+ ipc::IPCResult RecvDeviceCreateSwapChain(
+ RawId aDeviceId, RawId aQueueId, const layers::RGBDescriptor& aDesc,
+ const nsTArray<RawId>& aBufferIds,
+ const layers::RemoteTextureOwnerId& aOwnerId,
+ bool aUseExternalTextureInSwapChain);
+ ipc::IPCResult RecvDeviceCreateShaderModule(
+ RawId aDeviceId, RawId aModuleId, const nsString& aLabel,
+ const nsCString& aCode, DeviceCreateShaderModuleResolver&& aOutMessage);
+
+ ipc::IPCResult RecvSwapChainPresent(
+ RawId aTextureId, RawId aCommandEncoderId,
+ const layers::RemoteTextureId& aRemoteTextureId,
+ const layers::RemoteTextureOwnerId& aOwnerId);
+ ipc::IPCResult RecvSwapChainDrop(const layers::RemoteTextureOwnerId& aOwnerId,
+ layers::RemoteTextureTxnType aTxnType,
+ layers::RemoteTextureTxnId aTxnId);
+
+ ipc::IPCResult RecvDeviceAction(RawId aDeviceId,
+ const ipc::ByteBuf& aByteBuf);
+ ipc::IPCResult RecvDeviceActionWithAck(
+ RawId aDeviceId, const ipc::ByteBuf& aByteBuf,
+ DeviceActionWithAckResolver&& aResolver);
+ ipc::IPCResult RecvTextureAction(RawId aTextureId, RawId aDevice,
+ const ipc::ByteBuf& aByteBuf);
+ ipc::IPCResult RecvCommandEncoderAction(RawId aEncoderId, RawId aDeviceId,
+ const ipc::ByteBuf& aByteBuf);
+ ipc::IPCResult RecvBumpImplicitBindGroupLayout(RawId aPipelineId,
+ bool aIsCompute,
+ uint32_t aIndex,
+ RawId aAssignId);
+
+ ipc::IPCResult RecvDevicePushErrorScope(RawId aDeviceId, dom::GPUErrorFilter);
+ ipc::IPCResult RecvDevicePopErrorScope(
+ RawId aDeviceId, DevicePopErrorScopeResolver&& aResolver);
+ ipc::IPCResult RecvGenerateError(Maybe<RawId> aDeviceId, dom::GPUErrorFilter,
+ const nsCString& message);
+
+ ipc::IPCResult GetFrontBufferSnapshot(
+ IProtocol* aProtocol, const layers::RemoteTextureOwnerId& aOwnerId,
+ Maybe<Shmem>& aShmem, gfx::IntSize& aSize);
+
+ void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ struct BufferMapData {
+ ipc::WritableSharedMemoryMapping mShmem;
+ // True if buffer's usage has MAP_READ or MAP_WRITE set.
+ bool mHasMapFlags;
+ uint64_t mMappedOffset;
+ uint64_t mMappedSize;
+ RawId mDeviceId;
+ };
+
+ BufferMapData* GetBufferMapData(RawId aBufferId);
+
+ bool UseExternalTextureForSwapChain(ffi::WGPUSwapChainId aSwapChainId);
+
+ bool EnsureExternalTextureForSwapChain(ffi::WGPUSwapChainId aSwapChainId,
+ ffi::WGPUDeviceId aDeviceId,
+ ffi::WGPUTextureId aTextureId,
+ uint32_t aWidth, uint32_t aHeight,
+ struct ffi::WGPUTextureFormat aFormat,
+ ffi::WGPUTextureUsages aUsage);
+
+ std::shared_ptr<ExternalTexture> CreateExternalTexture(
+ ffi::WGPUDeviceId aDeviceId, ffi::WGPUTextureId aTextureId,
+ uint32_t aWidth, uint32_t aHeight,
+ const struct ffi::WGPUTextureFormat aFormat,
+ ffi::WGPUTextureUsages aUsage);
+
+ std::shared_ptr<ExternalTexture> GetExternalTexture(ffi::WGPUTextureId aId);
+
+ void PostExternalTexture(
+ const std::shared_ptr<ExternalTexture>&& aExternalTexture,
+ const layers::RemoteTextureId aRemoteTextureId,
+ const layers::RemoteTextureOwnerId aOwnerId);
+
+ bool ForwardError(const RawId aDeviceId, ErrorBuffer& aError) {
+ return ForwardError(Some(aDeviceId), aError);
+ }
+
+ private:
+ static void MapCallback(ffi::WGPUBufferMapAsyncStatus aStatus,
+ uint8_t* aUserData);
+ static void DeviceLostCallback(uint8_t* aUserData, uint8_t aReason,
+ const char* aMessage);
+ void DeallocBufferShmem(RawId aBufferId);
+
+ void RemoveExternalTexture(RawId aTextureId);
+
+ virtual ~WebGPUParent();
+ void MaintainDevices();
+ void LoseDevice(const RawId aDeviceId, Maybe<uint8_t> aReason,
+ const nsACString& aMessage);
+
+ bool ForwardError(Maybe<RawId> aDeviceId, ErrorBuffer& aError);
+
+ void ReportError(Maybe<RawId> aDeviceId, GPUErrorFilter,
+ const nsCString& message);
+
+ static Maybe<ffi::WGPUFfiLUID> GetCompositorDeviceLuid();
+
+ UniquePtr<ffi::WGPUGlobal> mContext;
+ base::RepeatingTimer<WebGPUParent> mTimer;
+
+ /// A map from wgpu buffer ids to data about their shared memory segments.
+ /// Includes entries about mappedAtCreation, MAP_READ and MAP_WRITE buffers,
+ /// regardless of their state.
+ std::unordered_map<uint64_t, BufferMapData> mSharedMemoryMap;
+ /// Associated presentation data for each swapchain.
+ std::unordered_map<layers::RemoteTextureOwnerId, RefPtr<PresentationData>,
+ layers::RemoteTextureOwnerId::HashFn>
+ mPresentationDataMap;
+
+ RefPtr<layers::RemoteTextureOwnerClient> mRemoteTextureOwner;
+
+ /// Associated stack of error scopes for each device.
+ std::unordered_map<uint64_t, std::vector<ErrorScope>>
+ mErrorScopeStackByDevice;
+
+ std::unordered_map<ffi::WGPUTextureId, std::shared_ptr<ExternalTexture>>
+ mExternalTextures;
+
+ // Store a set of DeviceIds that have been SendDeviceLost. We use this to
+ // limit each Device to one DeviceLost message.
+ nsTHashSet<RawId> mLostDeviceIds;
+
+ // Shared handle of wgpu device's fence.
+ RefPtr<gfx::FileHandleWrapper> mFenceHandle;
+
+ // Store DeviceLostRequest structs for each device as unique_ptrs mapped
+ // to their device ids. We keep these unique_ptrs alive as long as the
+ // device is alive.
+ struct DeviceLostRequest {
+ WeakPtr<WebGPUParent> mParent;
+ RawId mDeviceId;
+ };
+ std::unordered_map<RawId, std::unique_ptr<DeviceLostRequest>>
+ mDeviceLostRequests;
+};
+
+} // namespace webgpu
+} // namespace mozilla
+
+#endif // WEBGPU_PARENT_H_