Partager via


Interface ID3D12CommandQueue (d3d12.h)

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