void FD3D12DynamicRHI::UnlockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer) { FD3D12LockedResource& LockedData = Buffer->LockedData; check(LockedData.bLocked == true); // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; if (bIsDynamic) { // If the Buffer is dynamic, its upload heap memory can always stay mapped. Don't do anything. } else { if (LockedData.bLockedForReadOnly) { //Nothing to do, just release the locked data at the end of the function } else { // Copy the contents of the temporary memory buffer allocated for writing into the Buffer. BufferType* CurrentBuffer = Buffer; // Update all of the resources in the LDA chain while (CurrentBuffer) { // If we are on the render thread, queue up the copy on the RHIThread so it happens at the correct time. if (ShouldDeferBufferLockOperation(RHICmdList)) { new (RHICmdList->AllocCommand<FRHICommandUpdateBuffer>()) FRHICommandUpdateBuffer(&CurrentBuffer->ResourceLocation, LockedData.ResourceLocation, LockedData.LockedOffset, LockedData.LockedPitch); } else { UpdateBuffer(CurrentBuffer->ResourceLocation.GetResource(), CurrentBuffer->ResourceLocation.GetOffsetFromBaseOfResource() + LockedData.LockedOffset, LockedData.ResourceLocation.GetResource(), LockedData.ResourceLocation.GetOffsetFromBaseOfResource(), LockedData.LockedPitch); } CurrentBuffer = CurrentBuffer->GetNextObject(); } } } LockedData.Reset(); }
void FD3D12DynamicRHI::UnlockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer) { // Find the outstanding lock for this Buffer. FD3D12LockedKey LockedKey(Buffer); FD3D12LockedData* LockedData = FindInOutstandingLocks(LockedKey); check(LockedData); // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; if (bIsDynamic) { // If the Buffer is dynamic, its upload heap memory can always stay mapped. Don't do anything. } else { // If the static Buffer lock involved a staging resource, it was locked for reading. if (LockedData->StagingResource) { // Unmap the staging buffer's memory. ID3D12Resource* StagingBuffer = LockedData->StagingResource.GetReference()->GetResource(); StagingBuffer->Unmap(0, nullptr); } else { // Copy the contents of the temporary memory buffer allocated for writing into the Buffer. FD3D12ResourceLocation* UploadHeapLocation = LockedData->UploadHeapLocation.GetReference(); // If we are on the render thread, queue up the copy on the RHIThread so it happens at the correct time. if (ShouldDeferBufferLockOperation(RHICmdList)) { new (RHICmdList->AllocCommand<FRHICommandUpdateBuffer>()) FRHICommandUpdateBuffer(Buffer->ResourceLocation, UploadHeapLocation, LockedData->Pitch); } else { UpdateBuffer(Buffer->ResourceLocation->GetResource(), Buffer->ResourceLocation->GetOffset(), UploadHeapLocation->GetResource(), UploadHeapLocation->GetOffset(), LockedData->Pitch); } } } // Remove the FD3D12LockedData from the lock map. // If the lock involved a staging resource, this releases it. RemoveFromOutstandingLocks(LockedKey); }
void* FD3D12DynamicRHI::LockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer, uint32 Offset, uint32 Size, EResourceLockMode LockMode) { FD3D12LockedData LockedData; // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; void* Data = nullptr; if (bIsDynamic) { check(LockMode == RLM_WriteOnly); TRefCountPtr<FD3D12ResourceLocation> newLocation = new FD3D12ResourceLocation(GetRHIDevice()); // Allocate a new resource Data = GetRHIDevice()->GetDefaultUploadHeapAllocator().AllocUploadResource(Buffer->ResourceLocation->GetEffectiveBufferSize(), Buffer->BufferAlignment, newLocation); // If on the RenderThread, queue up a command on the RHIThread to rename this buffer at the correct time if (ShouldDeferBufferLockOperation(RHICmdList)) { new (RHICmdList->AllocCommand<FRHICommandRenameUploadBuffer<BufferType>>()) FRHICommandRenameUploadBuffer<BufferType>(Buffer, newLocation); } else { Buffer->Rename(newLocation); } } else { FD3D12Resource* pResource = Buffer->ResourceLocation->GetResource(); // Locking for read must occur immediately so we can't queue up the operations later. if (LockMode == RLM_ReadOnly) { // If the static buffer is being locked for reading, create a staging buffer. TRefCountPtr<FD3D12Resource> StagingBuffer; VERIFYD3D11RESULT(GetRHIDevice()->GetResourceHelper().CreateBuffer(D3D12_HEAP_TYPE_READBACK, Offset + Size, StagingBuffer.GetInitReference())); LockedData.StagingResource = StagingBuffer; // Copy the contents of the buffer to the staging buffer. { const auto& pfnCopyContents = [&]() { FD3D12CommandContext& DefaultContext = GetRHIDevice()->GetDefaultCommandContext(); FD3D12CommandListHandle& hCommandList = DefaultContext.CommandListHandle; FScopeResourceBarrier ScopeResourceBarrierSource(hCommandList, pResource, pResource->GetDefaultResourceState(), D3D12_RESOURCE_STATE_COPY_SOURCE, 0); // Don't need to transition upload heaps DefaultContext.numCopies++; hCommandList->CopyBufferRegion( StagingBuffer->GetResource(), 0, pResource->GetResource(), Offset, Size); DefaultContext.FlushCommands(true); }; if (ShouldDeferBufferLockOperation(RHICmdList)) { // Sync when in the render thread implementation check(IsInRHIThread() == false); RHICmdList->ImmediateFlush(EImmediateFlushType::FlushRHIThread); pfnCopyContents(); } else { check(IsInRHIThread()); pfnCopyContents(); } } // Map the staging buffer's memory for reading. VERIFYD3D11RESULT(StagingBuffer->GetResource()->Map(0, nullptr, &Data)); } else { // If the static buffer is being locked for writing, allocate memory for the contents to be written to. TRefCountPtr<FD3D12ResourceLocation> UploadBufferLocation = new FD3D12ResourceLocation(GetRHIDevice()); Data = GetRHIDevice()->GetDefaultFastAllocator().Allocate(Offset + Size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT, UploadBufferLocation); // Keep track of the underlying resource for the upload heap so it can be referenced during Unmap. LockedData.UploadHeapLocation = UploadBufferLocation; } } check(Data); // Add the lock to the lock map. LockedData.SetData(Data); LockedData.Pitch = Offset + Size; // Add the lock to the lock map. FD3D12LockedKey LockedKey(Buffer); AddToOutstandingLocks(LockedKey, LockedData); // Return the offset pointer return (void*)((uint8*)LockedData.GetData() + Offset); }
void* FD3D12DynamicRHI::LockBuffer(FRHICommandListImmediate* RHICmdList, BufferType* Buffer, uint32 Offset, uint32 Size, EResourceLockMode LockMode) { #if STATS LockBufferCalls++; SCOPE_CYCLE_COUNTER(STAT_D3D12LockBufferTime); INC_DWORD_STAT_BY(STAT_D3D12LockBufferCalls, LockBufferCalls); #endif FD3D12LockedResource& LockedData = Buffer->LockedData; check(LockedData.bLocked == false); FD3D12Device* Device = GetRHIDevice(); FD3D12Adapter& Adapter = GetAdapter(); // Determine whether the buffer is dynamic or not. const bool bIsDynamic = (Buffer->GetUsage() & BUF_AnyDynamic) ? true : false; void* Data = nullptr; if (bIsDynamic) { check(LockMode == RLM_WriteOnly); BufferType* CurrentBuffer = Buffer; // Update all of the resources in the LDA chain while (CurrentBuffer) { // Allocate a new resource // If on the RenderThread, queue up a command on the RHIThread to rename this buffer at the correct time if (ShouldDeferBufferLockOperation(RHICmdList)) { FRHICommandRenameUploadBuffer<BufferType>* Command = new (RHICmdList->AllocCommand<FRHICommandRenameUploadBuffer<BufferType>>()) FRHICommandRenameUploadBuffer<BufferType>(CurrentBuffer, Device); Data = Adapter.GetUploadHeapAllocator().AllocUploadResource(Buffer->GetSize(), Buffer->BufferAlignment, Command->NewResource); } else { FD3D12ResourceLocation Location(CurrentBuffer->GetParentDevice()); Data = Adapter.GetUploadHeapAllocator().AllocUploadResource(Buffer->GetSize(), Buffer->BufferAlignment, Location); CurrentBuffer->Rename(Location); } CurrentBuffer = CurrentBuffer->GetNextObject(); } } else { FD3D12Resource* pResource = Buffer->ResourceLocation.GetResource(); // Locking for read must occur immediately so we can't queue up the operations later. if (LockMode == RLM_ReadOnly) { LockedData.bLockedForReadOnly = true; // If the static buffer is being locked for reading, create a staging buffer. FD3D12Resource* StagingBuffer = nullptr; const GPUNodeMask Node = Device->GetNodeMask(); VERIFYD3D12RESULT(Adapter.CreateBuffer(D3D12_HEAP_TYPE_READBACK, Node, Node, Offset + Size, &StagingBuffer)); // Copy the contents of the buffer to the staging buffer. { const auto& pfnCopyContents = [&]() { FD3D12CommandContext& DefaultContext = Device->GetDefaultCommandContext(); FD3D12CommandListHandle& hCommandList = DefaultContext.CommandListHandle; FScopeResourceBarrier ScopeResourceBarrierSource(hCommandList, pResource, pResource->GetDefaultResourceState(), D3D12_RESOURCE_STATE_COPY_SOURCE, 0); // Don't need to transition upload heaps DefaultContext.numCopies++; hCommandList->CopyBufferRegion( StagingBuffer->GetResource(), 0, pResource->GetResource(), Offset, Size); hCommandList.UpdateResidency(StagingBuffer); hCommandList.UpdateResidency(pResource); DefaultContext.FlushCommands(true); }; if (ShouldDeferBufferLockOperation(RHICmdList)) { // Sync when in the render thread implementation check(IsInRHIThread() == false); RHICmdList->ImmediateFlush(EImmediateFlushType::FlushRHIThread); pfnCopyContents(); } else { check(IsInRHIThread()); pfnCopyContents(); } } LockedData.ResourceLocation.AsStandAlone(StagingBuffer, Size); Data = LockedData.ResourceLocation.GetMappedBaseAddress(); } else { // If the static buffer is being locked for writing, allocate memory for the contents to be written to. Data = Device->GetDefaultFastAllocator().Allocate<FD3D12ScopeLock>(Size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT, &LockedData.ResourceLocation); } } LockedData.LockedOffset = Offset; LockedData.LockedPitch = Size; LockedData.bLocked = true; // Return the offset pointer check(Data != nullptr); return Data; }