ID3D12GraphicsCommandList::ResourceBarrier-Methode (d3d12.h)

  • Artikel

Benachrichtigt den Treiber, dass er mehrere Zugriffe auf Ressourcen synchronisieren muss.

Syntax

void ResourceBarrier(
  [in] UINT                         NumBarriers,
  [in] const D3D12_RESOURCE_BARRIER *pBarriers
);

Parameter

[in] NumBarriers

Typ: UINT

Die Anzahl der eingereichten Barrierenbeschreibungen.

[in] pBarriers

Typ: const D3D12_RESOURCE_BARRIER*

Zeiger auf ein Array von Barrierebeschreibungen.

Rückgabewert

Keine

Bemerkungen

Hinweis

Eine Ressource, die für den D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE Zustand verwendet werden soll, muss in diesem Zustand erstellt werden, und sie muss dann nie aus ihr übergehen. Eine Ressource, die nicht in diesem Zustand erstellt wurde, darf auch nicht in sie übergehen. Weitere Informationen finden Sie unter Speichereinschränkungen der Beschleunigungsstruktur in der DirectX-Raytracing-Funktionsspezifikation (DXR) auf GitHub.

Es gibt drei Arten von Barrierebeschreibungen:

  • D3D12_RESOURCE_TRANSITION_BARRIER : Übergangsbarrieren deuten darauf hin, dass eine Reihe von Unterressourcen zwischen verschiedenen Nutzungen wechselt. Der Aufrufer muss die Vor - und Nachnutzungen der Unterressourcen angeben. Das flag D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES wird verwendet, um alle Unterressourcen in einer Ressource gleichzeitig zu übergeben.
  • D3D12_RESOURCE_ALIASING_BARRIER : Aliasing-Barrieren deuten auf einen Übergang zwischen der Verwendung von zwei verschiedenen Ressourcen hin, die Zuordnungen in denselben Heap aufweisen. Die Anwendung kann sowohl die Vor- als auch die Nachher-Ressource angeben. Beachten Sie, dass eine oder beide Ressourcen NULL sein können (was angibt, dass jede gekachelte Ressource Aliasing verursachen kann).
  • D3D12_RESOURCE_UAV_BARRIER : Barrieren für ungeordnete Zugriffsansichten weisen darauf hin, dass alle UAV-Zugriffe (Lese- oder Schreibzugriffe) auf eine bestimmte Ressource abgeschlossen sein müssen, bevor alle zukünftigen UAV-Zugriffe (Lese- oder Schreibzugriff) beginnen können. Die angegebene Ressource kann NULL sein. Es ist nicht erforderlich, eine UAV-Barriere zwischen zwei Draw- oder Dispatch-Aufrufen einzufügen, die nur ein UAV lesen. Darüber hinaus ist es nicht erforderlich, eine UAV-Barriere zwischen zwei Zeichen- oder Aussendungsaufrufen einzufügen, die in dieselbe UAV schreiben, wenn die Anwendung weiß, dass die UAV-Zugriffe in beliebiger Reihenfolge sicher ausgeführt werden können. Die Ressource kann NULL sein (was angibt, dass für jeden UAV-Zugriff die Barriere erforderlich sein könnte).
Wenn ID3D12GraphicsCommandList::ResourceBarrier ein Array von Ressourcenbarrierebeschreibungen übergeben wird, verhält sich die API so, als würde sie N mal (1 für jedes Arrayelement) in der angegebenen Reihenfolge aufgerufen. Übergänge sollten nach Möglichkeit als Leistungsoptimierung in einem einzelnen API-Aufruf zusammengefasst werden.

Beschreibungen der Nutzungszustände, in die sich eine Unterquelle befinden kann, finden Sie im Abschnitt D3D12_RESOURCE_STATES Enumeration und Verwenden von Ressourcenbarrieren zum Synchronisieren von Ressourcenzuständen in Direct3D 12 .

Alle Unterressourcen in einer Ressource müssen sich für Renderziele bzw. Tiefenschablonenressourcen im zustand RENDER_TARGET oder DEPTH_WRITE befinden, wenn ID3D12GraphicsCommandList::D iscardResource aufgerufen wird.

Wenn ein Backpuffer angezeigt wird, muss er sich im D3D12_RESOURCE_STATE_PRESENT Zustand befinden. Wenn IDXGISwapChain1::P resent1 für eine Ressource aufgerufen wird, die sich nicht im ZUSTAND PRESENT befindet, wird eine Debugebenenwarnung ausgegeben.

Die Ressourcennutzungsbits werden in zwei Kategorien gruppiert: schreibgeschützt und Lese-/Schreibzugriff.

Die folgenden Verwendungsbits sind schreibgeschützt:

  • D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER
  • D3D12_RESOURCE_STATE_INDEX_BUFFER
  • D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE
  • D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE
  • D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT
  • D3D12_RESOURCE_STATE_COPY_SOURCE
  • D3D12_RESOURCE_STATE_DEPTH_READ
Die folgenden Verwendungsbits sind Lese-/Schreibvorgänge:
  • D3D12_RESOURCE_STATE_UNORDERED_ACCESS
  • D3D12_RESOURCE_STATE_DEPTH_WRITE
Die folgenden Verwendungsbits sind schreibgeschützt:
  • D3D12_RESOURCE_STATE_COPY_DEST
  • D3D12_RESOURCE_STATE_RENDER_TARGET
  • D3D12_RESOURCE_STATE_STREAM_OUT
Es kann höchstens ein Schreibbit festgelegt werden. Wenn ein Schreibbit festgelegt ist, kann kein Lesebit festgelegt werden. Wenn kein Schreibbit festgelegt ist, kann eine beliebige Anzahl von Lesebits festgelegt werden.

Eine Unterquelle befindet sich jederzeit in genau einem Zustand (bestimmt durch eine Reihe von Flags). Die Anwendung muss sicherstellen, dass die Zustände übereinstimmen, wenn eine Sequenz von ResourceBarrier-Aufrufen ausgeführt wird. Anders ausgedrückt: Die Vorher- und Nachher-Zustände in aufeinander folgenden Aufrufen von ResourceBarrier müssen zustimmen.

Zum Übergang aller Unterressourcen innerhalb einer Ressource kann die Anwendung den Unterressourcenindex auf D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES festlegen, was bedeutet, dass alle Unterressourcen geändert werden.

Um die Leistung zu verbessern, sollten Anwendungen geteilte Barrieren verwenden (siehe Synchronisierung mit mehreren Engines). Ihre Anwendung sollte außerdem nach Möglichkeit mehrere Übergänge in einen einzelnen Aufruf batchieren.

Laufzeitüberprüfung

Die Runtime überprüft, ob die Werte des Barrierentyps gültige Member der D3D12_RESOURCE_BARRIER_TYPE-Enumeration sind.

Darüber hinaus überprüft die Runtime Folgendes:

  • Der Ressourcenzeiger ist nicht NULL.
  • Der Unterressourcenindex ist gültig.
  • Die Vorher- und Nachher-Zustände werden von den D3D12_RESOURCE_BINDING_TIER - und D3D12_RESOURCE_FLAGS-Flags der Ressource unterstützt.
  • Reservierte Bits in den Zustandsmasken sind nicht festgelegt.
  • Die Vorher- und Nachher-Zustände unterscheiden sich.
  • Der Satz von Bits im Vor- und Nachher-Status ist gültig.
  • Wenn das D3D12_RESOURCE_STATE_RESOLVE_SOURCE Bit festgelegt ist, muss die Anzahl der Ressourcenbeispiele größer als 1 sein.
  • Wenn das D3D12_RESOURCE_STATE_RESOLVE_DEST Bits festgelegt ist, muss die Anzahl der Ressourcenbeispiele gleich 1 sein.
Beim Aliasen von Barrieren überprüft die Runtime, dass, wenn ein Ressourcenzeiger nicht NULL ist, auf eine gekachelte Ressource verweist.

Bei UAV-Barrieren überprüft die Runtime, dass die Ressource das D3D12_RESOURCE_STATE_UNORDERED_ACCESS Bindungsflag festgelegt hat, wenn die Ressource nicht NULL ist.

Überprüfungsfehler bewirkt , dass ID3D12GraphicsCommandList::Close E_INVALIDARG zurückgibt.

Debugebene

Die Debugebene gibt normalerweise Fehler aus, bei denen die Laufzeitüberprüfung fehlschlägt:
  • Wenn ein Unterressourcenübergang in einer Befehlsliste mit früheren Übergängen in derselben Befehlsliste inkonsistent ist.
  • Wenn eine Ressource verwendet wird, ohne zuerst ResourceBarrier aufzurufen, um die Ressource in den richtigen Zustand zu versetzen.
  • Wenn eine Ressource illegal gleichzeitig für Lese- und Schreibzugriff gebunden ist.
  • Wenn die anden ResourceBarrier übergebenen before-Zustände nicht mit den Nachzuständen früherer Aufrufe von ResourceBarrier übereinstimmen, einschließlich der Aliasing-Großschreibung.
Während die Debugebene versucht, die Laufzeitregeln zu überprüfen, arbeitet sie konservativ, sodass Fehler auf Debugebene echte Fehler sind, und in einigen Fällen können echte Fehler keine Fehler auf Debugebenen verursachen.

Die Debugebene gibt in den folgenden Fällen Warnungen aus:

  • Alle Fälle, in denen die D3D12-Debugebene Warnungen für ID3D12GraphicsCommandList::ResourceBarrier ausgibt.
  • Wenn ein Tiefenpuffer in einem nicht schreibgeschützten Modus verwendet wird, während für die Ressource das D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE Nutzungsbit festgelegt ist.

Beispiele

Das D3D12HelloTriangle-Beispiel verwendet ID3D12GraphicsCommandList::ResourceBarrier wie folgt:

D3D12_VIEWPORT m_viewport;
D3D12_RECT m_scissorRect;
ComPtr<IDXGISwapChain3> m_swapChain;
ComPtr<ID3D12Device> m_device;
ComPtr<ID3D12Resource> m_renderTargets[FrameCount];
ComPtr<ID3D12CommandAllocator> m_commandAllocator;
ComPtr<ID3D12CommandQueue> m_commandQueue;
ComPtr<ID3D12RootSignature> m_rootSignature;
ComPtr<ID3D12DescriptorHeap> m_rtvHeap;
ComPtr<ID3D12PipelineState> m_pipelineState;
ComPtr<ID3D12GraphicsCommandList> m_commandList;
UINT m_rtvDescriptorSize;


void D3D12HelloTriangle::PopulateCommandList()
{
    // Command list allocators can only be reset when the associated 
    // command lists have finished execution on the GPU; apps should use 
    // fences to determine GPU execution progress.
    ThrowIfFailed(m_commandAllocator->Reset());

    // However, when ExecuteCommandList() is called on a particular command 
    // list, that command list can then be reset at any time and must be before 
    // re-recording.
    ThrowIfFailed(m_commandList->Reset(m_commandAllocator.Get(), m_pipelineState.Get()));

    // Set necessary state.
    m_commandList->SetGraphicsRootSignature(m_rootSignature.Get());
    m_commandList->RSSetViewports(1, &m_viewport);
    m_commandList->RSSetScissorRects(1, &m_scissorRect);

    // Indicate that the back buffer will be used as a render target.
    m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET));

    CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), m_frameIndex, m_rtvDescriptorSize);
    m_commandList->OMSetRenderTargets(1, &rtvHandle, FALSE, nullptr);

    // Record commands.
    const float clearColor[] = { 0.0f, 0.2f, 0.4f, 1.0f };
    m_commandList->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr);
    m_commandList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    m_commandList->IASetVertexBuffers(0, 1, &m_vertexBufferView);
    m_commandList->DrawInstanced(3, 1, 0, 0);

    // Indicate that the back buffer will now be used to present.
    m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_renderTargets[m_frameIndex].Get(), D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT));

    ThrowIfFailed(m_commandList->Close());
}

Siehe Beispielcode in der D3D12-Referenz.

Anforderungen

   
Zielplattform Windows
Kopfzeile d3d12.h
Bibliothek D3d12.lib
DLL D3d12.dll

Weitere Informationen

ID3D12GraphicsCommandList

Verwenden von Ressourcenbarrieren zum Synchronisieren von Ressourcenzuständen in Direct3D 12