Simulação de gravidade de n-corpos de vários mecanismos
O exemplo D3D12nBodyGravity demonstra como fazer com que a computação funcione de forma assíncrona. O exemplo cria vários threads cada um com uma fila de comandos de computação e agenda o trabalho de computação na GPU que executa uma simulação de gravidade n-corpo. Cada thread opera em dois buffers cheios de dados de posição e velocidade. A cada iteração, o sombreador de computação lê os dados atuais de posição e velocidade de um buffer e grava a próxima iteração no outro buffer. Quando a iteração é concluída, o sombreador de computação troca qual buffer é o SRV para ler dados de posição/velocidade e que é o UAV para gravar atualizações de posição/velocidade alterando o estado do recurso em cada buffer.
- Criar as assinaturas raiz
- Criar os buffers SRV e UAV
- Criar o CBV e buffers de vértice
- Sincronizar os threads de renderização e computação
- Execute o exemplo
- Tópicos relacionados
Criar as assinaturas raiz
Começamos criando um elemento gráfico e uma assinatura raiz de computação, no método LoadAssets . Ambas as assinaturas raiz têm uma CBV (exibição de buffer constante raiz) e uma tabela de descritor SRV (exibição de recurso de sombreador). A assinatura raiz de computação também tem uma tabela de descritor UAV (modo de exibição de acesso não ordenado).
// 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)));
}
Criar os buffers SRV e UAV
Os buffers SRV e UAV consistem em uma matriz de dados de posição e velocidade.
// 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;
};
| Fluxo de chamada | Parâmetros |
|---|---|
| XMFLOAT4 |
Criar o CBV e buffers de vértice
Para o pipeline gráfico, o CBV é um struct que contém duas matrizes usadas pelo sombreador de geometria. O sombreador de geometria assume a posição de cada partícula no sistema e gera um quad para representá-lo usando essas matrizes.
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];
};
| Fluxo de chamada | Parâmetros |
|---|---|
| XMMATRIX |
Como resultado, o buffer de vértice usado pelo sombreador de vértice não contém dados posicionais.
// "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;
};
| Fluxo de chamada | Parâmetros |
|---|---|
| XMFLOAT4 |
Para o pipeline de computação, o CBV é um struct que contém algumas constantes usadas pela simulação de gravidade n-corpo no sombreador de computação.
struct ConstantBufferCS
{
UINT param[4];
float paramf[4];
};
Sincronizar os threads de renderização e computação
Depois que todos os buffers forem inicializados, o trabalho de computação e renderização será iniciado. O thread de computação alterará o estado dos dois buffers de posição/velocidade entre SRV e UAV à medida que itera na simulação, e o thread de renderização precisa garantir que ele agende o trabalho no pipeline gráfico que opera no SRV. As cercas são usadas para sincronizar o acesso aos dois buffers.
No thread Renderizar:
// 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();
}
| Fluxo de chamada | Parâmetros |
|---|---|
| InterlockedExchange | |
| InterlockedGetValue | |
| GetCompletedValue | |
| Aguarde | |
| ID3D12CommandList | |
| ExecuteCommandLists | |
| IDXGISwapChain1::Present1 |
Para simplificar um pouco o exemplo, o thread de computação aguarda que a GPU conclua cada iteração antes de agendar mais trabalho de computação. Na prática, os aplicativos provavelmente desejarão manter a fila de computação cheia para obter o desempenho máximo da GPU.
No thread Computação:
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;
}
Execute o exemplo
Tópicos relacionados
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de