| // Copyright 2023 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "dawn/native/d3d11/DeviceD3D11.h" |
| |
| #include <algorithm> |
| #include <limits> |
| #include <sstream> |
| #include <utility> |
| |
| #include "dawn/common/GPUInfo.h" |
| #include "dawn/native/ChainUtils.h" |
| #include "dawn/native/D3D11Backend.h" |
| #include "dawn/native/DynamicUploader.h" |
| #include "dawn/native/Instance.h" |
| #include "dawn/native/d3d/D3DError.h" |
| #include "dawn/native/d3d/ExternalImageDXGIImpl.h" |
| #include "dawn/native/d3d/KeyedMutex.h" |
| #include "dawn/native/d3d/UtilsD3D.h" |
| #include "dawn/native/d3d11/BackendD3D11.h" |
| #include "dawn/native/d3d11/BindGroupD3D11.h" |
| #include "dawn/native/d3d11/BindGroupLayoutD3D11.h" |
| #include "dawn/native/d3d11/BufferD3D11.h" |
| #include "dawn/native/d3d11/CommandBufferD3D11.h" |
| #include "dawn/native/d3d11/ComputePipelineD3D11.h" |
| #include "dawn/native/d3d11/PhysicalDeviceD3D11.h" |
| #include "dawn/native/d3d11/PipelineLayoutD3D11.h" |
| #include "dawn/native/d3d11/PlatformFunctionsD3D11.h" |
| #include "dawn/native/d3d11/QuerySetD3D11.h" |
| #include "dawn/native/d3d11/QueueD3D11.h" |
| #include "dawn/native/d3d11/RenderPipelineD3D11.h" |
| #include "dawn/native/d3d11/SamplerD3D11.h" |
| #include "dawn/native/d3d11/ShaderModuleD3D11.h" |
| #include "dawn/native/d3d11/SharedFenceD3D11.h" |
| #include "dawn/native/d3d11/SharedTextureMemoryD3D11.h" |
| #include "dawn/native/d3d11/SwapChainD3D11.h" |
| #include "dawn/native/d3d11/TextureD3D11.h" |
| #include "dawn/native/d3d11/UtilsD3D11.h" |
| #include "dawn/platform/DawnPlatform.h" |
| #include "dawn/platform/tracing/TraceEvent.h" |
| |
| namespace dawn::native::d3d11 { |
| namespace { |
| |
| static constexpr uint64_t kMaxDebugMessagesToPrint = 5; |
| |
| void AppendDebugLayerMessagesToError(ID3D11InfoQueue* infoQueue, |
| uint64_t totalErrors, |
| ErrorData* error) { |
| DAWN_ASSERT(totalErrors > 0); |
| DAWN_ASSERT(error != nullptr); |
| |
| uint64_t errorsToPrint = std::min(kMaxDebugMessagesToPrint, totalErrors); |
| for (uint64_t i = 0; i < errorsToPrint; ++i) { |
| std::ostringstream messageStream; |
| SIZE_T messageLength = 0; |
| HRESULT hr = infoQueue->GetMessage(i, nullptr, &messageLength); |
| if (FAILED(hr)) { |
| messageStream << " ID3D11InfoQueue::GetMessage failed with " << hr; |
| error->AppendBackendMessage(messageStream.str()); |
| continue; |
| } |
| |
| std::unique_ptr<uint8_t[]> messageData(new uint8_t[messageLength]); |
| D3D11_MESSAGE* message = reinterpret_cast<D3D11_MESSAGE*>(messageData.get()); |
| hr = infoQueue->GetMessage(i, message, &messageLength); |
| if (FAILED(hr)) { |
| messageStream << " ID3D11InfoQueue::GetMessage failed with " << hr; |
| error->AppendBackendMessage(messageStream.str()); |
| continue; |
| } |
| |
| messageStream << message->pDescription << " (" << message->ID << ")"; |
| error->AppendBackendMessage(messageStream.str()); |
| } |
| if (errorsToPrint < totalErrors) { |
| std::ostringstream messages; |
| messages << (totalErrors - errorsToPrint) << " messages silenced"; |
| error->AppendBackendMessage(messages.str()); |
| } |
| |
| // We only print up to the first kMaxDebugMessagesToPrint errors |
| infoQueue->ClearStoredMessages(); |
| } |
| |
| } // namespace |
| |
| // static |
| ResultOrError<Ref<Device>> Device::Create(AdapterBase* adapter, |
| const UnpackedPtr<DeviceDescriptor>& descriptor, |
| const TogglesState& deviceToggles, |
| Ref<DeviceBase::DeviceLostEvent>&& lostEvent) { |
| Ref<Device> device = |
| AcquireRef(new Device(adapter, descriptor, deviceToggles, std::move(lostEvent))); |
| DAWN_TRY(device->Initialize(descriptor)); |
| return device; |
| } |
| |
| MaybeError Device::Initialize(const UnpackedPtr<DeviceDescriptor>& descriptor) { |
| DAWN_TRY_ASSIGN(mD3d11Device, ToBackend(GetPhysicalDevice())->CreateD3D11Device()); |
| DAWN_ASSERT(mD3d11Device != nullptr); |
| |
| mIsDebugLayerEnabled = IsDebugLayerEnabled(mD3d11Device); |
| |
| // Get the ID3D11Device5 interface which is need for creating fences. |
| // TODO(dawn:1741): Handle the case where ID3D11Device5 is not available. |
| DAWN_TRY(CheckHRESULT(mD3d11Device.As(&mD3d11Device5), "D3D11: getting ID3D11Device5")); |
| |
| Ref<Queue> queue; |
| DAWN_TRY_ASSIGN(queue, Queue::Create(this, &descriptor->defaultQueue)); |
| |
| DAWN_TRY(DeviceBase::Initialize(queue)); |
| DAWN_TRY(queue->InitializePendingContext()); |
| |
| SetLabelImpl(); |
| |
| return {}; |
| } |
| |
| Device::~Device() = default; |
| |
| ID3D11Device* Device::GetD3D11Device() const { |
| return mD3d11Device.Get(); |
| } |
| |
| ID3D11Device5* Device::GetD3D11Device5() const { |
| return mD3d11Device5.Get(); |
| } |
| |
| MaybeError Device::TickImpl() { |
| // Check for debug layer messages before executing the command context in case we encounter an |
| // error during execution and early out as a result. |
| DAWN_TRY(CheckDebugLayerAndGenerateErrors()); |
| DAWN_TRY(ToBackend(GetQueue())->SubmitPendingCommands()); |
| return {}; |
| } |
| |
| void Device::ReferenceUntilUnused(ComPtr<IUnknown> object) { |
| mUsedComObjectRefs.Enqueue(object, GetQueue()->GetPendingCommandSerial()); |
| } |
| |
| ResultOrError<Ref<BindGroupBase>> Device::CreateBindGroupImpl( |
| const BindGroupDescriptor* descriptor) { |
| return BindGroup::Create(this, descriptor); |
| } |
| |
| ResultOrError<Ref<BindGroupLayoutInternalBase>> Device::CreateBindGroupLayoutImpl( |
| const BindGroupLayoutDescriptor* descriptor) { |
| return BindGroupLayout::Create(this, descriptor); |
| } |
| |
| ResultOrError<Ref<BufferBase>> Device::CreateBufferImpl( |
| const UnpackedPtr<BufferDescriptor>& descriptor) { |
| return Buffer::Create(this, descriptor, /*commandContext=*/nullptr); |
| } |
| |
| ResultOrError<Ref<CommandBufferBase>> Device::CreateCommandBuffer( |
| CommandEncoder* encoder, |
| const CommandBufferDescriptor* descriptor) { |
| return CommandBuffer::Create(encoder, descriptor); |
| } |
| |
| Ref<ComputePipelineBase> Device::CreateUninitializedComputePipelineImpl( |
| const UnpackedPtr<ComputePipelineDescriptor>& descriptor) { |
| return ComputePipeline::CreateUninitialized(this, descriptor); |
| } |
| |
| ResultOrError<Ref<PipelineLayoutBase>> Device::CreatePipelineLayoutImpl( |
| const UnpackedPtr<PipelineLayoutDescriptor>& descriptor) { |
| return PipelineLayout::Create(this, descriptor); |
| } |
| |
| ResultOrError<Ref<QuerySetBase>> Device::CreateQuerySetImpl(const QuerySetDescriptor* descriptor) { |
| return QuerySet::Create(this, descriptor); |
| } |
| |
| Ref<RenderPipelineBase> Device::CreateUninitializedRenderPipelineImpl( |
| const UnpackedPtr<RenderPipelineDescriptor>& descriptor) { |
| return RenderPipeline::CreateUninitialized(this, descriptor); |
| } |
| |
| ResultOrError<Ref<SamplerBase>> Device::CreateSamplerImpl(const SamplerDescriptor* descriptor) { |
| return Sampler::Create(this, descriptor); |
| } |
| |
| ResultOrError<Ref<ShaderModuleBase>> Device::CreateShaderModuleImpl( |
| const UnpackedPtr<ShaderModuleDescriptor>& descriptor, |
| ShaderModuleParseResult* parseResult, |
| OwnedCompilationMessages* compilationMessages) { |
| return ShaderModule::Create(this, descriptor, parseResult, compilationMessages); |
| } |
| |
| ResultOrError<Ref<SwapChainBase>> Device::CreateSwapChainImpl(Surface* surface, |
| SwapChainBase* previousSwapChain, |
| const SurfaceConfiguration* config) { |
| return SwapChain::Create(this, surface, previousSwapChain, config); |
| } |
| |
| ResultOrError<Ref<TextureBase>> Device::CreateTextureImpl( |
| const UnpackedPtr<TextureDescriptor>& descriptor) { |
| return Texture::Create(this, descriptor); |
| } |
| |
| ResultOrError<Ref<TextureViewBase>> Device::CreateTextureViewImpl( |
| TextureBase* texture, |
| const UnpackedPtr<TextureViewDescriptor>& descriptor) { |
| return TextureView::Create(texture, descriptor); |
| } |
| |
| void Device::InitializeComputePipelineAsyncImpl(Ref<CreateComputePipelineAsyncEvent> event) { |
| event->InitializeAsync(); |
| } |
| |
| void Device::InitializeRenderPipelineAsyncImpl(Ref<CreateRenderPipelineAsyncEvent> event) { |
| event->InitializeAsync(); |
| } |
| |
| ResultOrError<Ref<SharedTextureMemoryBase>> Device::ImportSharedTextureMemoryImpl( |
| const SharedTextureMemoryDescriptor* descriptor) { |
| UnpackedPtr<SharedTextureMemoryDescriptor> unpacked; |
| DAWN_TRY_ASSIGN(unpacked, ValidateAndUnpack(descriptor)); |
| |
| wgpu::SType type; |
| DAWN_TRY_ASSIGN( |
| type, (unpacked.ValidateBranches<Branch<SharedTextureMemoryDXGISharedHandleDescriptor>, |
| Branch<SharedTextureMemoryD3D11Texture2DDescriptor>>())); |
| |
| switch (type) { |
| case wgpu::SType::SharedTextureMemoryDXGISharedHandleDescriptor: |
| DAWN_INVALID_IF(!HasFeature(Feature::SharedTextureMemoryDXGISharedHandle), |
| "%s is not enabled.", |
| wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle); |
| return SharedTextureMemory::Create( |
| this, descriptor->label, |
| unpacked.Get<SharedTextureMemoryDXGISharedHandleDescriptor>()); |
| case wgpu::SType::SharedTextureMemoryD3D11Texture2DDescriptor: |
| DAWN_INVALID_IF(!HasFeature(Feature::SharedTextureMemoryD3D11Texture2D), |
| "%s is not enabled.", |
| wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D); |
| return SharedTextureMemory::Create( |
| this, descriptor->label, |
| unpacked.Get<SharedTextureMemoryD3D11Texture2DDescriptor>()); |
| default: |
| DAWN_UNREACHABLE(); |
| } |
| } |
| |
| ResultOrError<Ref<SharedFenceBase>> Device::ImportSharedFenceImpl( |
| const SharedFenceDescriptor* descriptor) { |
| UnpackedPtr<SharedFenceDescriptor> unpacked; |
| DAWN_TRY_ASSIGN(unpacked, ValidateAndUnpack(descriptor)); |
| |
| wgpu::SType type; |
| DAWN_TRY_ASSIGN(type, |
| (unpacked.ValidateBranches<Branch<SharedFenceDXGISharedHandleDescriptor>>())); |
| |
| switch (type) { |
| case wgpu::SType::SharedFenceDXGISharedHandleDescriptor: |
| DAWN_INVALID_IF(!HasFeature(Feature::SharedFenceDXGISharedHandle), "%s is not enabled.", |
| wgpu::FeatureName::SharedFenceDXGISharedHandle); |
| return SharedFence::Create(this, descriptor->label, |
| unpacked.Get<SharedFenceDXGISharedHandleDescriptor>()); |
| default: |
| DAWN_UNREACHABLE(); |
| } |
| } |
| |
| MaybeError Device::CopyFromStagingToBufferImpl(BufferBase* source, |
| uint64_t sourceOffset, |
| BufferBase* destination, |
| uint64_t destinationOffset, |
| uint64_t size) { |
| // D3D11 requires that buffers are unmapped before being used in a copy. |
| DAWN_TRY(source->Unmap()); |
| |
| auto commandContext = |
| ToBackend(GetQueue())->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal); |
| return Buffer::Copy(&commandContext, ToBackend(source), sourceOffset, size, |
| ToBackend(destination), destinationOffset); |
| } |
| |
| MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source, |
| const TextureDataLayout& src, |
| const TextureCopy& dst, |
| const Extent3D& copySizePixels) { |
| return DAWN_UNIMPLEMENTED_ERROR("CopyFromStagingToTextureImpl"); |
| } |
| |
| const DeviceInfo& Device::GetDeviceInfo() const { |
| return ToBackend(GetPhysicalDevice())->GetDeviceInfo(); |
| } |
| |
| MaybeError Device::CheckDebugLayerAndGenerateErrors() { |
| if (!mIsDebugLayerEnabled) { |
| return {}; |
| } |
| |
| ComPtr<ID3D11InfoQueue> infoQueue; |
| DAWN_TRY(CheckHRESULT(mD3d11Device.As(&infoQueue), |
| "D3D11 QueryInterface ID3D11Device to ID3D11InfoQueue")); |
| uint64_t totalErrors = infoQueue->GetNumStoredMessagesAllowedByRetrievalFilter(); |
| |
| // Check if any errors have occurred otherwise we would be creating an empty error. Note |
| // that we use GetNumStoredMessagesAllowedByRetrievalFilter instead of GetNumStoredMessages |
| // because we only convert WARNINGS or higher messages to dawn errors. |
| if (totalErrors == 0) { |
| return {}; |
| } |
| |
| auto error = DAWN_INTERNAL_ERROR("The D3D11 debug layer reported uncaught errors."); |
| |
| AppendDebugLayerMessagesToError(infoQueue.Get(), totalErrors, error.get()); |
| |
| return error; |
| } |
| |
| void Device::AppendDebugLayerMessages(ErrorData* error) { |
| if (!GetPhysicalDevice()->GetInstance()->IsBackendValidationEnabled()) { |
| return; |
| } |
| |
| ComPtr<ID3D11InfoQueue> infoQueue; |
| if (FAILED(mD3d11Device.As(&infoQueue))) { |
| return; |
| } |
| uint64_t totalErrors = infoQueue->GetNumStoredMessagesAllowedByRetrievalFilter(); |
| |
| if (totalErrors == 0) { |
| return; |
| } |
| |
| AppendDebugLayerMessagesToError(infoQueue.Get(), totalErrors, error); |
| } |
| |
| void Device::AppendDeviceLostMessage(ErrorData* error) { |
| if (mD3d11Device) { |
| HRESULT result = mD3d11Device->GetDeviceRemovedReason(); |
| error->AppendBackendMessage("Device removed reason: %s (0x%08X)", |
| d3d::HRESULTAsString(result), result); |
| } |
| } |
| |
| void Device::DestroyImpl() { |
| // TODO(crbug.com/dawn/831): DestroyImpl is called from two places. |
| // - It may be called if the device is explicitly destroyed with APIDestroy. |
| // This case is NOT thread-safe and needs proper synchronization with other |
| // simultaneous uses of the device. |
| // - It may be called when the last ref to the device is dropped and the device |
| // is implicitly destroyed. This case is thread-safe because there are no |
| // other threads using the device since there are no other live refs. |
| DAWN_ASSERT(GetState() == State::Disconnected); |
| |
| mImplicitPixelLocalStorageAttachmentTextureViews = {}; |
| mStagingBuffers.clear(); |
| |
| Base::DestroyImpl(); |
| } |
| |
| uint32_t Device::GetOptimalBytesPerRowAlignment() const { |
| return 256; |
| } |
| |
| uint64_t Device::GetOptimalBufferToTextureCopyOffsetAlignment() const { |
| return 1; |
| } |
| |
| float Device::GetTimestampPeriodInNS() const { |
| return 1.0f; |
| } |
| |
| void Device::SetLabelImpl() {} |
| |
| ResultOrError<FenceAndSignalValue> Device::CreateFence( |
| const d3d::ExternalImageDXGIFenceDescriptor* externalImageFenceDesc) { |
| SharedFenceDXGISharedHandleDescriptor sharedFenceDesc; |
| sharedFenceDesc.handle = externalImageFenceDesc->fenceHandle; |
| |
| Ref<SharedFence> fence; |
| DAWN_TRY_ASSIGN(fence, SharedFence::Create(this, "Imported DXGI fence", &sharedFenceDesc)); |
| |
| return FenceAndSignalValue{std::move(fence), externalImageFenceDesc->fenceValue}; |
| } |
| |
| ResultOrError<std::unique_ptr<d3d::ExternalImageDXGIImpl>> Device::CreateExternalImageDXGIImplImpl( |
| const ExternalImageDescriptor* descriptor) { |
| // ExternalImageDXGIImpl holds a weak reference to the device. If the device is destroyed before |
| // the image is created, the image will have a dangling reference to the device which can cause |
| // a use-after-free. |
| DAWN_TRY(ValidateIsAlive()); |
| |
| ComPtr<ID3D11Resource> d3d11Resource; |
| ComPtr<IDXGIKeyedMutex> dxgiKeyedMutex; |
| switch (descriptor->GetType()) { |
| case ExternalImageType::DXGISharedHandle: { |
| const auto* sharedHandleDescriptor = |
| static_cast<const d3d::ExternalImageDescriptorDXGISharedHandle*>(descriptor); |
| DAWN_TRY(CheckHRESULT( |
| mD3d11Device5->OpenSharedResource1(sharedHandleDescriptor->sharedHandle, |
| IID_PPV_ARGS(&d3d11Resource)), |
| "D3D11 OpenSharedResource1")); |
| if (sharedHandleDescriptor->useKeyedMutex) { |
| d3d11Resource.As(&dxgiKeyedMutex); |
| DAWN_INVALID_IF(!dxgiKeyedMutex, |
| "Failed to retrieve DXGI keyed mutex when expected"); |
| } |
| break; |
| } |
| case ExternalImageType::D3D11Texture: { |
| const auto* d3d11TextureDescriptor = |
| static_cast<const d3d::ExternalImageDescriptorD3D11Texture*>(descriptor); |
| DAWN_TRY(CheckHRESULT(d3d11TextureDescriptor->texture.As(&d3d11Resource), |
| "Cannot get ID3D11Resource from texture")); |
| ComPtr<ID3D11Device> textureDevice; |
| d3d11Resource->GetDevice(textureDevice.GetAddressOf()); |
| DAWN_INVALID_IF( |
| textureDevice.Get() != mD3d11Device.Get(), |
| "The D3D11 device of the texture and the D3D11 device of the WebGPU device " |
| "must be same."); |
| d3d11Resource.As(&dxgiKeyedMutex); |
| break; |
| } |
| default: { |
| return DAWN_VALIDATION_ERROR("descriptor type (%d) is not supported", |
| static_cast<int>(descriptor->GetType())); |
| } |
| } |
| |
| UnpackedPtr<TextureDescriptor> textureDescriptor; |
| DAWN_TRY_ASSIGN(textureDescriptor, ValidateAndUnpack(FromAPI(descriptor->cTextureDescriptor))); |
| DAWN_TRY( |
| ValidateTextureDescriptor(this, textureDescriptor, AllowMultiPlanarTextureFormat::Yes)); |
| |
| DAWN_TRY_CONTEXT(d3d::ValidateTextureDescriptorCanBeWrapped(textureDescriptor), |
| "validating that a D3D11 external image can be wrapped with %s", |
| textureDescriptor); |
| |
| DAWN_TRY(ValidateTextureCanBeWrapped(d3d11Resource.Get(), textureDescriptor)); |
| |
| // Shared handle is assumed to support resource sharing capability. The resource |
| // shared capability tier must agree to share resources between D3D devices. |
| const Format* format = GetInternalFormat(textureDescriptor->format).AcquireSuccess(); |
| if (format->IsMultiPlanar() && descriptor->GetType() == ExternalImageType::DXGISharedHandle) { |
| DAWN_TRY(ValidateVideoTextureCanBeShared( |
| this, d3d::DXGITextureFormat(textureDescriptor->format))); |
| } |
| |
| Ref<d3d::KeyedMutex> keyedMutex; |
| if (dxgiKeyedMutex) { |
| keyedMutex = AcquireRef(new d3d::KeyedMutex(this, std::move(dxgiKeyedMutex))); |
| } |
| |
| return std::make_unique<d3d::ExternalImageDXGIImpl>(this, std::move(d3d11Resource), |
| std::move(keyedMutex), textureDescriptor); |
| } |
| |
| void Device::DisposeKeyedMutex(ComPtr<IDXGIKeyedMutex> dxgiKeyedMutex) { |
| // Nothing to do, the ComPtr will release the keyed mutex. |
| } |
| |
| bool Device::MayRequireDuplicationOfIndirectParameters() const { |
| return true; |
| } |
| |
| uint64_t Device::GetBufferCopyOffsetAlignmentForDepthStencil() const { |
| return DeviceBase::GetBufferCopyOffsetAlignmentForDepthStencil(); |
| } |
| |
| bool Device::IsResolveTextureBlitWithDrawSupported() const { |
| return true; |
| } |
| |
| Ref<TextureBase> Device::CreateD3DExternalTexture(const UnpackedPtr<TextureDescriptor>& descriptor, |
| ComPtr<IUnknown> d3dTexture, |
| Ref<d3d::KeyedMutex> keyedMutex, |
| std::vector<FenceAndSignalValue> waitFences, |
| bool isSwapChainTexture, |
| bool isInitialized) { |
| Ref<Texture> dawnTexture; |
| if (ConsumedError(Texture::CreateExternalImage(this, descriptor, std::move(d3dTexture), |
| std::move(keyedMutex), std::move(waitFences), |
| isSwapChainTexture, isInitialized), |
| &dawnTexture)) { |
| return nullptr; |
| } |
| return {dawnTexture}; |
| } |
| |
| uint32_t Device::GetUAVSlotCount() const { |
| return ToBackend(GetPhysicalDevice())->GetUAVSlotCount(); |
| } |
| |
| ResultOrError<TextureViewBase*> Device::GetOrCreateCachedImplicitPixelLocalStorageAttachment( |
| uint32_t width, |
| uint32_t height, |
| uint32_t implicitAttachmentIndex) { |
| DAWN_ASSERT(implicitAttachmentIndex <= kMaxPLSSlots); |
| |
| TextureViewBase* currentAttachmentView = |
| mImplicitPixelLocalStorageAttachmentTextureViews[implicitAttachmentIndex].Get(); |
| if (currentAttachmentView == nullptr || |
| currentAttachmentView->GetTexture()->GetWidth(Aspect::Color) < width || |
| currentAttachmentView->GetTexture()->GetHeight(Aspect::Color) < height) { |
| // Create one 2D texture for each attachment. Note that currently on D3D11 backend we cannot |
| // create a Texture2D UAV on a 2D array texture with baseArrayLayer > 0 because D3D11 |
| // requires the Unordered Access View dimension declared in the shader code must match the |
| // view type bound to the Pixel Shader unit, while TEXTURE2D doesn't match TEXTURE2DARRAY. |
| // TODO(dawn:1703): support 2D array storage textures as implicit pixel local storage |
| // attachments in WGSL. |
| TextureDescriptor desc; |
| desc.dimension = wgpu::TextureDimension::e2D; |
| desc.format = RenderPipelineBase::kImplicitPLSSlotFormat; |
| desc.usage = wgpu::TextureUsage::StorageAttachment; |
| desc.size = {width, height, 1}; |
| |
| Ref<TextureBase> newAttachment; |
| DAWN_TRY_ASSIGN(newAttachment, CreateTexture(&desc)); |
| DAWN_TRY_ASSIGN(mImplicitPixelLocalStorageAttachmentTextureViews[implicitAttachmentIndex], |
| newAttachment->CreateView()); |
| } |
| return mImplicitPixelLocalStorageAttachmentTextureViews[implicitAttachmentIndex].Get(); |
| } |
| |
| ResultOrError<Ref<BufferBase>> Device::GetStagingBuffer( |
| const ScopedCommandRecordingContext* commandContext, |
| uint64_t size) { |
| constexpr uint64_t kMinStagingBufferSize = 4 * 1024; |
| uint64_t bufferSize = Align(size, kMinStagingBufferSize); |
| BufferDescriptor descriptor; |
| descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc; |
| descriptor.size = bufferSize; |
| descriptor.mappedAtCreation = false; |
| descriptor.label = "DawnDeviceStagingBuffer"; |
| Ref<BufferBase> buffer; |
| // We don't cache the buffer if it's too large. |
| if (bufferSize > kMaxStagingBufferSize) { |
| DAWN_TRY_ASSIGN(buffer, Buffer::Create(this, Unpack(&descriptor), commandContext, |
| /*allowUploadBufferEmulation=*/false)); |
| return buffer; |
| } |
| |
| ExecutionSerial completedSerial = GetQueue()->GetCompletedCommandSerial(); |
| for (auto it = mStagingBuffers.begin(); it != mStagingBuffers.end(); ++it) { |
| if ((*it)->GetLastUsageSerial() > completedSerial) { |
| // This buffer, and none after it are ready. Advance to the end and stop the search. |
| break; |
| } |
| |
| if ((*it)->GetSize() >= bufferSize) { |
| // this buffer is large enough. Stop searching and remove. |
| buffer = *it; |
| mStagingBuffers.erase(it); |
| return buffer; |
| } |
| } |
| |
| // Create a new staging buffer as no existing one can be re-used. |
| DAWN_TRY_ASSIGN(buffer, Buffer::Create(this, Unpack(&descriptor), commandContext, |
| /*allowUploadBufferEmulation=*/false)); |
| mTotalStagingBufferSize += bufferSize; |
| |
| // Purge the old staging buffers if the total size is too large. |
| constexpr uint64_t kMaxTotalSize = 16 * 1024 * 1024; |
| for (auto it = mStagingBuffers.begin(); it != mStagingBuffers.end() && |
| mTotalStagingBufferSize > kMaxTotalSize && |
| (*it)->GetLastUsageSerial() <= completedSerial;) { |
| mTotalStagingBufferSize -= (*it)->GetSize(); |
| it = mStagingBuffers.erase(it); |
| } |
| |
| return buffer; |
| } |
| |
| void Device::ReturnStagingBuffer(Ref<BufferBase>&& buffer) { |
| DAWN_ASSERT(mStagingBuffers.empty() || |
| mStagingBuffers.back()->GetLastUsageSerial() <= buffer->GetLastUsageSerial()); |
| // Only the cached buffers can be re-used. |
| if (buffer->GetSize() <= kMaxStagingBufferSize) { |
| mStagingBuffers.push_back(std::move(buffer)); |
| } |
| } |
| |
| } // namespace dawn::native::d3d11 |