N-Körper-Schwerkraftsimulation mit mehreren Modulen
Das D3D12nBodyGravity-Beispiel veranschaulicht, wie Computearbeit asynchron ausgeführt wird. Das Beispiel startet eine Reihe von Threads mit jeweils einer Computebefehlswarteschlange und plant Computearbeit auf der GPU, die eine n-Körper-Schwerkraftsimulation ausführt. Jeder Thread arbeitet mit zwei Puffern voller Positions- und Geschwindigkeitsdaten. Bei jeder Iteration liest der Compute-Shader die aktuelle Position und die Geschwindigkeitsdaten aus einem Puffer und schreibt die nächste Iteration in den anderen Puffer. Nach Abschluss der Iteration wechselt der Compute-Shader, welcher Puffer die SRV zum Lesen von Positions-/Geschwindigkeitsdaten ist, und welches UAV zum Schreiben von Positions-/Geschwindigkeitsupdates ist, indem der Ressourcenzustand für jeden Puffer geändert wird.
- Erstellen der Stammsignaturen
- Erstellen der SRV- und UAV-Puffer
- Erstellen der CBV- und Vertexpuffer
- Synchronisieren der Rendering- und Computethreads
- Ausführen des Beispiels
- Zugehörige Themen
Erstellen der Stammsignaturen
Wir beginnen mit der Erstellung einer Grafik und einer Computestammsignatur in der LoadAssets-Methode . Beide Stammsignaturen verfügen über eine Root Constant Buffer View (CBV) und eine SrV-Deskriptortabelle (Shader Resource View). Die Computestammsignatur verfügt auch über eine Unordered Access View (UAV)-Deskriptortabelle.
// Create the root signatures.
{
CD3DX12_DESCRIPTOR_RANGE ranges[2];
ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0);
ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 1, 0);
CD3DX12_ROOT_PARAMETER rootParameters[RootParametersCount];
rootParameters[RootParameterCB].InitAsConstantBufferView(0, 0, D3D12_SHADER_VISIBILITY_ALL);
rootParameters[RootParameterSRV].InitAsDescriptorTable(1, &ranges[0], D3D12_SHADER_VISIBILITY_VERTEX);
rootParameters[RootParameterUAV].InitAsDescriptorTable(1, &ranges[1], D3D12_SHADER_VISIBILITY_ALL);
// The rendering pipeline does not need the UAV parameter.
CD3DX12_ROOT_SIGNATURE_DESC rootSignatureDesc;
rootSignatureDesc.Init(_countof(rootParameters) - 1, rootParameters, 0, nullptr, D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
ComPtr<ID3DBlob> signature;
ComPtr<ID3DBlob> error;
ThrowIfFailed(D3D12SerializeRootSignature(&rootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_rootSignature)));
// Create compute signature. Must change visibility for the SRV.
rootParameters[RootParameterSRV].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
CD3DX12_ROOT_SIGNATURE_DESC computeRootSignatureDesc(_countof(rootParameters), rootParameters, 0, nullptr);
ThrowIfFailed(D3D12SerializeRootSignature(&computeRootSignatureDesc, D3D_ROOT_SIGNATURE_VERSION_1, &signature, &error));
ThrowIfFailed(m_device->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&m_computeRootSignature)));
}
Erstellen der SRV- und UAV-Puffer
Die SRV- und UAV-Puffer bestehen aus einem Array von Positions- und Geschwindigkeitsdaten.
// Position and velocity data for the particles in the system.
// Two buffers full of Particle data are utilized in this sample.
// The compute thread alternates writing to each of them.
// The render thread renders using the buffer that is not currently
// in use by the compute shader.
struct Particle
{
XMFLOAT4 position;
XMFLOAT4 velocity;
};
| Anrufverlauf | Parameter |
|---|---|
| XMFLOAT4 |
Erstellen der CBV- und Vertexpuffer
Für die Grafikpipeline ist die CBV eine Struktur , die zwei Matrizen enthält, die vom Geometry-Shader verwendet werden. Der Geometry-Shader übernimmt die Position jedes Partikels im System und generiert ein Quad, um es mithilfe dieser Matrizen darzustellen.
struct ConstantBufferGS
{
XMMATRIX worldViewProjection;
XMMATRIX inverseView;
// Constant buffers are 256-byte aligned in GPU memory. Padding is added
// for convenience when computing the struct's size.
float padding[32];
};
| Anrufverlauf | Parameter |
|---|---|
| XMMATRIX |
Daher enthält der vom Vertexshader verwendete Vertexpuffer tatsächlich keine Positionsdaten.
// "Vertex" definition for particles. Triangle vertices are generated
// by the geometry shader. Color data will be assigned to those
// vertices via this struct.
struct ParticleVertex
{
XMFLOAT4 color;
};
| Anrufverlauf | Parameter |
|---|---|
| XMFLOAT4 |
Für die Computepipeline ist die CBV eine Struktur , die einige Konstanten enthält, die von der n-Körper-Schwerkraftsimulation im Compute-Shader verwendet werden.
struct ConstantBufferCS
{
UINT param[4];
float paramf[4];
};
Synchronisieren der Rendering- und Computethreads
Nachdem alle Puffer initialisiert wurden, beginnen die Rendering- und Computearbeit. Der Computethread ändert den Zustand der beiden Positions-/Geschwindigkeitspuffer zwischen SRV und UAV, während die Simulation durchlaufen wird, und der Renderingthread muss sicherstellen, dass er die Arbeit an der Grafikpipeline plant, die auf der SRV ausgeführt wird. Zäune werden verwendet, um den Zugriff auf die beiden Puffer zu synchronisieren.
Gehen Sie im Renderthread wie folgt vor:
// Render the scene.
void D3D12nBodyGravity::OnRender()
{
// Let the compute thread know that a new frame is being rendered.
for (int n = 0; n < ThreadCount; n++)
{
InterlockedExchange(&m_renderContextFenceValues[n], m_renderContextFenceValue);
}
// Compute work must be completed before the frame can render or else the SRV
// will be in the wrong state.
for (UINT n = 0; n < ThreadCount; n++)
{
UINT64 threadFenceValue = InterlockedGetValue(&m_threadFenceValues[n]);
if (m_threadFences[n]->GetCompletedValue() < threadFenceValue)
{
// Instruct the rendering command queue to wait for the current
// compute work to complete.
ThrowIfFailed(m_commandQueue->Wait(m_threadFences[n].Get(), threadFenceValue));
}
}
// Record all the commands we need to render the scene into the command list.
PopulateCommandList();
// Execute the command list.
ID3D12CommandList* ppCommandLists[] = { m_commandList.Get() };
m_commandQueue->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists);
// Present the frame.
ThrowIfFailed(m_swapChain->Present(0, 0));
MoveToNextFrame();
}
| Anrufverlauf | Parameter |
|---|---|
| InterlockedExchange | |
| InterlockedGetValue | |
| GetCompletedValue | |
| Wait | |
| ID3D12CommandList | |
| ExecuteCommandLists | |
| IDXGISwapChain1::Present1 |
Um das Beispiel ein wenig zu vereinfachen, wartet der Computethread, bis die GPU jede Iteration abgeschlossen hat, bevor weitere Computearbeit geplant wird. In der Praxis möchten Anwendungen wahrscheinlich die Computewarteschlange voll halten, um die maximale Leistung der GPU zu erzielen.
Im Computethread:
DWORD D3D12nBodyGravity::AsyncComputeThreadProc(int threadIndex)
{
ID3D12CommandQueue* pCommandQueue = m_computeCommandQueue[threadIndex].Get();
ID3D12CommandAllocator* pCommandAllocator = m_computeAllocator[threadIndex].Get();
ID3D12GraphicsCommandList* pCommandList = m_computeCommandList[threadIndex].Get();
ID3D12Fence* pFence = m_threadFences[threadIndex].Get();
while (0 == InterlockedGetValue(&m_terminating))
{
// Run the particle simulation.
Simulate(threadIndex);
// Close and execute the command list.
ThrowIfFailed(pCommandList->Close());
ID3D12CommandList* ppCommandLists[] = { pCommandList };
pCommandQueue->ExecuteCommandLists(1, ppCommandLists);
// Wait for the compute shader to complete the simulation.
UINT64 threadFenceValue = InterlockedIncrement(&m_threadFenceValues[threadIndex]);
ThrowIfFailed(pCommandQueue->Signal(pFence, threadFenceValue));
ThrowIfFailed(pFence->SetEventOnCompletion(threadFenceValue, m_threadFenceEvents[threadIndex]));
WaitForSingleObject(m_threadFenceEvents[threadIndex], INFINITE);
// Wait for the render thread to be done with the SRV so that
// the next frame in the simulation can run.
UINT64 renderContextFenceValue = InterlockedGetValue(&m_renderContextFenceValues[threadIndex]);
if (m_renderContextFence->GetCompletedValue() < renderContextFenceValue)
{
ThrowIfFailed(pCommandQueue->Wait(m_renderContextFence.Get(), renderContextFenceValue));
InterlockedExchange(&m_renderContextFenceValues[threadIndex], 0);
}
// Swap the indices to the SRV and UAV.
m_srvIndex[threadIndex] = 1 - m_srvIndex[threadIndex];
// Prepare for the next frame.
ThrowIfFailed(pCommandAllocator->Reset());
ThrowIfFailed(pCommandList->Reset(pCommandAllocator, m_computeState.Get()));
}
return 0;
}
Ausführen des Beispiels
