Fence-Based Gestão de Recursos

Mostra como gerenciar a vida útil dos dados do recurso acompanhando o progresso da GPU por meio de cercas. A memória pode ser efetivamente reutilizada com cercas gerenciando cuidadosamente a disponibilidade de espaço livre na memória, como em uma implementação de buffer de anel para uma pilha de upload.

• Cenário de buffer de anel
• Amostra de buffer de anel
• Tópicos relacionados

Cenário de buffer de anel

A seguir está um exemplo em que um aplicativo experimenta uma demanda rara por memória de pilha de upload.

Um buffer de anel é uma maneira de gerenciar uma pilha de upload. O buffer de anel contém os dados necessários para os próximos quadros. O aplicativo mantém um ponteiro de entrada de dados atual e uma fila de deslocamento de quadro para registrar cada quadro e iniciar o deslocamento de dados de recurso para esse quadro.

Um aplicativo cria um buffer de anel com base em um buffer para carregar dados para a GPU para cada quadro. Atualmente, o quadro 2 foi renderizado, o buffer de anel envolve os dados para o quadro 4, todos os dados necessários para o quadro 5 estão presentes e um grande buffer constante necessário para o quadro 6 precisa ser subalocado.

Figura 1: o aplicativo tenta subalocar para o buffer constante, mas encontra memória livre insuficiente.

Figura 2: Através da sondagem de cerca, o aplicativo descobre que o quadro 3 foi renderizado, a fila de deslocamento de quadro é atualizada e o estado atual do buffer de anel segue - no entanto, a memória livre ainda não é grande o suficiente para acomodar o buffer constante.

Figura 3: dada a situação, a CPU se bloqueia (via cerca de espera) até que o quadro 4 tenha sido renderizado, o que libera a memória subalocada para o quadro 4.

Figura 4: agora a memória livre é grande o suficiente para o buffer constante, e a subalocação é bem-sucedida; O aplicativo copia os dados do buffer da grande constante para a memória usada anteriormente pelos dados de recursos para os quadros 3 e 4. O ponteiro de entrada atual é finalmente atualizado.

Se um aplicativo implementa um buffer de anel, o buffer de anel deve ser grande o suficiente para lidar com o pior cenário dos tamanhos de dados de recursos.

Amostra de tampão de anel

O código de exemplo a seguir mostra como um buffer de anel pode ser gerenciado, prestando atenção à rotina de subalocação que lida com sondagem de cerca e espera. Para simplificar, o exemplo usa NOT_SUFFICIENT_MEMORY para ocultar os detalhes de "memória livre insuficiente encontrada na pilha", uma vez que essa lógica (baseada em m_pDataCur e deslocamentos dentro FrameOffsetQueue) não está intimamente relacionada a pilhas ou cercas. A amostra é simplificada para sacrificar a taxa de quadros em vez da utilização da memória.

Observe que, espera-se que o suporte a buffer de anel seja um cenário popular; No entanto, o design de pilha não impede outro uso, como parametrização e reutilização da lista de comandos.

struct FrameResourceOffset
{
    UINT frameIndex;
    UINT8* pResourceOffset;
};
std::queue<FrameResourceOffset> frameOffsetQueue;

void DrawFrame()
{
    float vertices[] = ...;
    UINT verticesOffset = 0;
    ThrowIfFailed(
        SetDataToUploadHeap(
            vertices, sizeof(float), sizeof(vertices) / sizeof(float), 
            4, // Max alignment requirement for vertex data is 4 bytes.
            verticesOffset
            ));

    float constants[] = ...;
    UINT constantsOffset = 0;
    ThrowIfFailed(
        SetDataToUploadHeap(
            constants, sizeof(float), sizeof(constants) / sizeof(float), 
            D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT,
            constantsOffset
            ));

    // Create vertex buffer views for the new binding model. 
    // Create constant buffer views for the new binding model. 
    // ...

    commandQueue->Execute(commandList);
    commandQueue->AdvanceFence();
}

HRESULT SuballocateFromHeap(SIZE_T uSize, UINT uAlign)
{
    if (NOT_SUFFICIENT_MEMORY(uSize, uAlign))
    {
        // Free up resources for frames processed by GPU; see Figure 2.
        UINT lastCompletedFrame = commandQueue->GetLastCompletedFence();
        FreeUpMemoryUntilFrame( lastCompletedFrame );

        while ( NOT_SUFFICIENT_MEMORY(uSize, uAlign)
            && !frameOffsetQueue.empty() )
        {
            // Block until a new frame is processed by GPU, then free up more memory; see Figure 3.
            UINT nextGPUFrame = frameOffsetQueue.front().frameIndex;
            commandQueue->SetEventOnFenceCompletion(nextGPUFrame, hEvent);
            WaitForSingleObject(hEvent, INFINITE);
            FreeUpMemoryUntilFrame( nextGPUFrame );
        }
    }

    if (NOT_SUFFICIENT_MEMORY(uSize, uAlign))
    {
        // Apps need to create a new Heap that is large enough for this resource.
        return E_HEAPNOTLARGEENOUGH;
    }
    else
    {
        // Update current data pointer for the new resource.
        m_pDataCur = reinterpret_cast<UINT8*>(
            Align(reinterpret_cast<SIZE_T>(m_pHDataCur), uAlign)
            );

        // Update frame offset queue if this is the first resource for a new frame; see Figure 4.
        UINT currentFrame = commandQueue->GetCurrentFence();
        if ( frameOffsetQueue.empty()
            || frameOffsetQueue.back().frameIndex < currentFrame )
        {
            FrameResourceOffset offset = {currentFrame, m_pDataCur};
            frameOffsetQueue.push(offset);
        }

        return S_OK;
    }
}

void FreeUpMemoryUntilFrame(UINT lastCompletedFrame)
{
    while ( !frameOffsetQueue.empty() 
        && frameOffsetQueue.first().frameIndex <= lastCompletedFrame )
    {
        frameOffsetQueue.pop();
    }
}

Tópicos relacionados

ID3D12Fence

Subalocação dentro de buffers