Interface ID3D12CommandQueue (d3d12.h)

Article
08/23/2023

Fournit des méthodes pour envoyer des listes de commandes, synchroniser l’exécution de la liste de commandes, instrumenter la file d’attente de commandes et mettre à jour les mappages de vignettes de ressources.

Héritage

L’interface ID3D12CommandQueue hérite d’ID3D12Pageable. ID3D12CommandQueue a également les types de membres suivants :

Méthodes

L’interface ID3D12CommandQueue a ces méthodes.


ID3D12CommandQueue::BeginEvent Non destinée à être appelée directement. Utilisez le runtime d’événements PIX pour insérer des événements dans une file d’attente de commandes. (ID3D12CommandQueue.BeginEvent)
ID3D12CommandQueue::CopyTileMappings Copie les mappages d’une ressource réservée source vers une ressource réservée de destination.
ID3D12CommandQueue::EndEvent Non destinée à être appelée directement. Utilisez le runtime d’événements PIX pour insérer des événements dans une file d’attente de commandes. (ID3D12CommandQueue.EndEvent)
ID3D12CommandQueue::ExecuteCommandLists Envoie un tableau de listes de commandes pour exécution.
ID3D12CommandQueue::GetClockCalibration Cette méthode échantillonne les compteurs d’horodatage processeur et GPU au même moment.
ID3D12CommandQueue::GetDesc Obtient la description de la file d’attente de commandes.
ID3D12CommandQueue::GetTimestampFrequency Cette méthode est utilisée pour déterminer la vitesse à laquelle le compteur d’horodatage GPU s’incrémente.
ID3D12CommandQueue::SetMarker Non destinée à être appelée directement. Utilisez le runtime d’événements PIX pour insérer des événements dans une file d’attente de commandes. (ID3D12CommandQueue.SetMarker)
ID3D12CommandQueue::Signal Mises à jour une clôture à une valeur spécifiée.
ID3D12CommandQueue::UpdateTileMappings Mises à jour mappages d’emplacements de vignettes dans des ressources réservées à des emplacements de mémoire dans un tas de ressources.
ID3D12CommandQueue::Wait Met en file d’attente une attente côté GPU et retourne immédiatement. Une attente côté GPU est l’endroit où le GPU attend que la clôture spécifiée atteigne ou dépasse la valeur spécifiée.

Notes

Utilisez ID3D12Device::CreateCommandQueue pour créer un objet de file d’attente de commandes.

Exemples

L’exemple D3D12nBodyGravity utilise ID3D12CommandQueue comme suit :

Déclarations de fichier d’en-tête.

// Compute objects.
ComPtr<ID3D12CommandAllocator> m_computeAllocator[ThreadCount];
ComPtr<ID3D12CommandQueue> m_computeCommandQueue[ThreadCount];
ComPtr<ID3D12GraphicsCommandList> m_computeCommandList[ThreadCount];

Thread de calcul asynchrone.

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;
}

Reportez-vous à l’exemple de code dans la référence D3D12.

Spécifications


Plateforme cible	Windows
En-tête	d3d12.h

Voir aussi

Interfaces principales

ID3D12Pageable

Partager via