Interfaccia ID3D12CommandQueue (d3d12.h)

Fornisce metodi per l'invio di elenchi di comandi, la sincronizzazione dell'esecuzione dell'elenco di comandi, la strumentazione della coda dei comandi e l'aggiornamento dei mapping dei riquadri delle risorse.

Ereditarietà

L'interfaccia ID3D12CommandQueue eredita da ID3D12Pageable. ID3D12CommandQueue include anche questi tipi di membri:

Metodi

L'interfaccia ID3D12CommandQueue include questi metodi.

ID3D12CommandQueue::BeginEvent Non deve essere chiamato direttamente.  Usare il runtime di eventi PIX per inserire eventi in una coda di comandi. (ID3D12CommandQueue.BeginEvent)
ID3D12CommandQueue::CopyTileMappings Copia i mapping da una risorsa riservata di origine a una risorsa riservata di destinazione.
ID3D12CommandQueue::EndEvent Non deve essere chiamato direttamente.  Usare il runtime di eventi PIX per inserire eventi in una coda di comandi. (ID3D12CommandQueue.EndEvent)
ID3D12CommandQueue::ExecuteCommandLists Invia una matrice di elenchi di comandi per l'esecuzione.
ID3D12CommandQueue::GetClockCalibration Questo metodo campiona i contatori timestamp cpu e GPU nello stesso momento.
ID3D12CommandQueue::GetDesc Ottiene la descrizione della coda dei comandi.
ID3D12CommandQueue::GetTimestampFrequency Questo metodo viene usato per determinare la frequenza con cui il contatore timestamp GPU incrementa.
ID3D12CommandQueue::SetMarker Non deve essere chiamato direttamente.  Usare il runtime di eventi PIX per inserire eventi in una coda di comandi. (ID3D12CommandQueue.SetMarker)
ID3D12CommandQueue::Signal Aggiornamenti un recinto a un valore specificato.
ID3D12CommandQueue::UpdateTileMappings Aggiornamenti mapping delle posizioni dei riquadri nelle risorse riservate ai percorsi di memoria in un heap delle risorse.
ID3D12CommandQueue::Wait Accoda un'attesa sul lato GPU e restituisce immediatamente. Un'attesa sul lato GPU è la posizione in cui la GPU attende fino a quando il limite specificato raggiunge o supera il valore specificato.

Commenti

Usare ID3D12Device::CreateCommandQueue per creare un oggetto coda di comandi.

Esempio

L'esempio D3D12nBodyGravity usa ID3D12CommandQueue come indicato di seguito:

Dichiarazioni di file di intestazione.

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

Thread di calcolo asincrono.

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

Fare riferimento al codice di esempio nel riferimento D3D12.

Requisiti

Piattaforma di destinazione	Windows
Intestazione	d3d12.h

Vedi anche

Interfacce di base

ID3D12Pageable