前言

GAMES104的王希說過：

遊戲引擎的世界裏，它的核心是靠Tick()函數把這個世界驅動起來。

本來單是一個CPU的計時器是不至於爲其寫一篇博客的，但把GPU計時器功能加上後就不一樣了。在這一篇中，我們將講述如何使用CPU計時器獲取幀間隔，以及使用GPU計時器獲取GPU中執行一系列指令的間隔。

歡迎加入QQ羣: 727623616 可以一起探討DX11，以及有什麼問題也可以在這裏彙報。

CPU計時器

在遊戲中，我們需要用到高精度的計時器。在這裏我們直接使用龍書的GameTimer，但爲了區分後續的GPU計時器，現在將其改名爲CpuTimer：

class CpuTimer
{
public:
    CpuTimer();
 
    float TotalTime()const;     // 返回從Reset()調用之後經過的時間，但不包括暫停期間的
    float DeltaTime()const;	    // 返回幀間隔時間

    void Reset();               // 計時開始前或者需要重置時調用
    void Start();               // 在開始計時或取消暫停的時候調用
    void Stop();                // 在需要暫停的時候調用
    void Tick();                // 在每一幀開始的時候調用
    bool IsStopped() const;     // 計時器是否暫停/結束

private:
    double m_SecondsPerCount = 0.0;
    double m_DeltaTime = -1.0;

    __int64 m_BaseTime = 0;
    __int64 m_PausedTime = 0;
    __int64 m_StopTime = 0;
    __int64 m_PrevTime = 0;
    __int64 m_CurrTime = 0;

    bool m_Stopped = false;
};

在構造函數中，我們將查詢計算機performance counter的頻率，因爲該頻率對於當前CPU是固定的，我們只需要在初始化階段獲取即可。然後我們可以求出單個count經過的時間：

CpuTimer::CpuTimer()
{
    __int64 countsPerSec{};
    QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
    m_SecondsPerCount = 1.0 / (double)countsPerSec;
}

在開始使用計數器之前，或者想要重置計時器時，我們需要調用一次Reset()，以當前時間作爲基準時間。這些__int64的類型存儲的單位爲count：

void CpuTimer::Reset()
{
    __int64 currTime{};
    QueryPerformanceCounter((LARGE_INTEGER*)&currTime);

    m_BaseTime = currTime;
    m_PrevTime = currTime;
    m_StopTime = 0;
    m_PausedTime = 0;	// 涉及到多次Reset的話需要將其歸0
    m_Stopped  = false;
}

然後這裏我們先看Stop()的實現，就是記錄當前Stop的時間和標記爲暫停中：

void CpuTimer::Stop()
{
    if( !m_Stopped )
    {
        __int64 currTime{};
        QueryPerformanceCounter((LARGE_INTEGER*)&currTime);

        m_StopTime = currTime;
        m_Stopped  = true;
    }
}

在調用Reset()完成初始化後，我們就可以調用Start()啓動計時了。當然如果之前調用過Stop()的話，將當前Stop()和Start()經過的暫停時間累加到總的暫停時間：

void CpuTimer::Start()
{
    __int64 startTime{};
    QueryPerformanceCounter((LARGE_INTEGER*)&startTime);


    // 累積暫停開始到暫停結束的這段時間
    //
    //                     |<-------d------->|
    // ----*---------------*-----------------*------------> time
    //  m_BaseTime       m_StopTime        startTime     

    if( m_Stopped )
    {
        m_PausedTime += (startTime - m_StopTime);

        m_PrevTime = startTime;
        m_StopTime = 0;
        m_Stopped  = false;
    }
}

然後在每一幀開始之前調用Tick()函數，更新當前幀與上一幀之間的間隔時間，該用時通過DeltaTime()獲取，可以用於物理世界的更新：

void CpuTimer::Tick()
{
    if( m_Stopped )
    {
        m_DeltaTime = 0.0;
        return;
    }

    __int64 currTime{};
    QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
    m_CurrTime = currTime;

    // 當前Tick與上一Tick的幀間隔
    m_DeltaTime = (m_CurrTime - m_PrevTime)*m_SecondsPerCount;

    m_PrevTime = m_CurrTime;

    if(m_DeltaTime < 0.0)
    {
        m_DeltaTime = 0.0;
    }
}

float CpuTimer::DeltaTime() const
{
    return (float)m_DeltaTime;
}

如果要獲取遊戲開始到現在經過的時間（不包括暫停期間），可以使用TotalTime()：

float CpuTimer::TotalTime()const
{
    // 如果調用了Stop()，暫停中的這段時間我們不需要計入。此外
    // m_StopTime - m_BaseTime可能會包含之前的暫停時間，爲
    // 此我們可以從m_StopTime減去之前累積的暫停的時間
    //
    //                     |<-- 暫停的時間 -->|
    // ----*---------------*-----------------*------------*------------*------> time
    //  m_BaseTime       m_StopTime        startTime     m_StopTime    m_CurrTime

    if( m_Stopped )
    {
        return (float)(((m_StopTime - m_PausedTime)-m_BaseTime)*m_SecondsPerCount);
    }

    // m_CurrTime - m_BaseTime包含暫停時間，但我們不想將它計入。
    // 爲此我們可以從m_CurrTime減去之前累積的暫停的時間
    //
    //  (m_CurrTime - m_PausedTime) - m_BaseTime 
    //
    //                     |<-- 暫停的時間 -->|
    // ----*---------------*-----------------*------------*------> time
    //  m_BaseTime       m_StopTime        startTime     m_CurrTime
    
    else
    {
        return (float)(((m_CurrTime-m_PausedTime)-m_BaseTime)*m_SecondsPerCount);
    }
}

總的來說，正常的調用順序是Reset()、Start()，然後每一幀調用Tick()，並獲取DeltaTime()。在需要暫停的時候就Stop()，恢復用Start()。

GPU計時器

假如我們需要統計某一個渲染過程的用時，如後處理、場景渲染、陰影繪製等，可能有人的想法是這樣的：

timer.Start();
DrawSomething();
timer.Tick();
float deltaTime = timer.DeltaTime();

實際上這樣並不能測量，因爲CPU跟GPU是異步執行的。設備上下文所調用的大部分方法實際上是向顯卡塞入命令然後立刻返回，這些命令被緩存到一個命令隊列中等待被消化。

因此，如果要測量GPU中一段執行過程的用時，我們需要向GPU插入兩個時間戳，然後將這兩個時間戳的Tick Count回讀到CPU，最後通過GPU獲取這期間的頻率來求出間隔。

目前GpuTimer放在Common文件夾中，供36章以後的項目使用，後續會考慮放到之前的項目中。

GpuTimer類的聲明如下：

class GpuTimer
{
public:
    GpuTimer() = default;
    
    // recentCount爲0時統計所有間隔的平均值
    // 否則統計最近N幀間隔的平均值
    void Init(ID3D11Device* device, ID3D11DeviceContext* deviceContext, size_t recentCount = 0);
    
    // 重置平均用時
    // recentCount爲0時統計所有間隔的平均值
    // 否則統計最近N幀間隔的平均值
    void Reset(ID3D11DeviceContext* deviceContext, size_t recentCount = 0);
    // 給命令隊列插入起始時間戳
    HRESULT Start();
    // 給命令隊列插入結束時間戳
    void Stop();
    // 嘗試獲取間隔
    bool TryGetTime(double* pOut);
    // 強制獲取間隔(可能會造成阻塞)
    double GetTime();
    // 計算平均用時
    double AverageTime()
    {
        if (m_RecentCount)
            return m_AccumTime / m_DeltaTimes.size();
        else
            return m_AccumTime / m_AccumCount;
    }

private:
    
    static bool GetQueryDataHelper(ID3D11DeviceContext* pContext, bool loopUntilDone, ID3D11Query* query, void* data, uint32_t dataSize);
    

    std::deque<double> m_DeltaTimes;    // 最近N幀的查詢間隔
    double m_AccumTime = 0.0;           // 查詢間隔的累計總和
    size_t m_AccumCount = 0;            // 完成回讀的查詢次數
    size_t m_RecentCount = 0;           // 保留最近N幀，0則包含所有

    std::deque<GpuTimerInfo> m_Queries; // 緩存未完成的查詢
    Microsoft::WRL::ComPtr<ID3D11Device> m_pDevice;
    Microsoft::WRL::ComPtr<ID3D11DeviceContext> m_pImmediateContext;
};

其中，Init()用於獲取D3D設備和設備上下文，並根據recentCount確定要統計最近N幀間隔的平均值，還是所有間隔的平均值：

void GpuTimer::Init(ID3D11Device* device, ID3D11DeviceContext* deviceContext, size_t recentCount)
{
    m_pDevice = device;
    m_pImmediateContext = deviceContext;
    m_RecentCount = recentCount;
    m_AccumTime = 0.0;
    m_AccumCount = 0;
}

在調用Init()後，我們就可以開始調用Start()來給命令隊列插入起始時間戳了。但在此之前，我們需要先介紹我們需要給命令隊列插入的具體是什麼。

ID3D11Device::CreateQueue--創建GPU查詢

爲了創建GPU查詢，我們需要先填充D3D11_QUERY_DESC結構體：

typedef struct D3D11_QUERY_DESC {
  D3D11_QUERY Query;
  UINT        MiscFlags;  // 目前填0
} D3D11_QUERY_DESC;

關於枚舉類型D3D11_QUERY，我們現在只關注其中兩個枚舉值：

D3D11_QUERY_TIMESTAMP：通過ID3D11DeviceContext::GetData返回的UINT64表示的是一個時間戳的值。該查詢還需要D3D11_QUERY_TIMESTAMP_DISJOINT的配合來判斷當前查詢是否有效。
D3D11_QUERY_TIMESTAMP_DISJOINT：用來確定當前的D3D11_QUERY_TIMESTAMP是否返回可信的結果，並可以獲取當前流處理器的頻率，來允許你將這兩個tick變換成經過的時間來求出間隔。該查詢只應該在每幀或多幀中執行一次，然後通過ID3D11DeviceContext::GetData返回D3D11_QUERY_DATA_TIMESTAMP_DISJOINT。

D3D11_QUERY_DATA_TIMESTAMP_DISJOINT的結構體如下：

typedef struct D3D11_QUERY_DATA_TIMESTAMP_DISJOINT {
  UINT64 Frequency;   // 當前GPU每秒增加的counter數目
  BOOL   Disjoint;    // 僅當其爲false時，兩個時間戳的詢問纔是有效的，表明這期間的頻率是固定的
                      // 若爲true，說明可能出現了拔開筆記本電源、過熱、由於節點模式導致的功耗降低等
} D3D11_QUERY_DATA_TIMESTAMP_DISJOINT;

由於從GPU回讀數據是一件很慢的事情，可能會拖慢1幀到幾幀，爲此我們需要把創建好的時間戳和頻率/連續性查詢先緩存起來。這裏使用的是GpuTimerInfo類

struct GpuTimerInfo
{
    D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData {};  // 頻率/連續性信息
    uint64_t startData = 0;  // 起始時間戳
    uint64_t stopData = 0;   // 結束時間戳
    Microsoft::WRL::ComPtr<ID3D11Query> disjointQuery;    // 連續性查詢
    Microsoft::WRL::ComPtr<ID3D11Query> startQuery;       // 起始時間戳查詢
    Microsoft::WRL::ComPtr<ID3D11Query> stopQuery;        // 結束時間戳查詢
    bool isStopped = false;                               // 是否插入了結束時間戳
};

在Start()中我們需要同時創建查詢、插入時間戳、開始連續性/頻率查詢。

HRESULT GpuTimer::Start()
{
    if (!m_Queries.empty() && !m_Queries.back().isStopped)
        return E_FAIL;

    GpuTimerInfo& info = m_Queries.emplace_back();
    CD3D11_QUERY_DESC queryDesc(D3D11_QUERY_TIMESTAMP);
    m_pDevice->CreateQuery(&queryDesc, info.startQuery.GetAddressOf());
    m_pDevice->CreateQuery(&queryDesc, info.stopQuery.GetAddressOf());
    queryDesc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;
    m_pDevice->CreateQuery(&queryDesc, info.disjointQuery.GetAddressOf());

    m_pImmediateContext->Begin(info.disjointQuery.Get());
    m_pImmediateContext->End(info.startQuery.Get());
    return S_OK;
}

需要注意的是，D3D11_QUERY_TIMESTAMP只通過ID3D11DeviceContext::End來插入起始時間戳；D3D11_QUERY_TIMESTAMP_DISJOINT則需要區分``ID3D11DeviceContext::Begin和ID3D11DeviceContext::End`。

在完成某個特效渲染後，我們可以調用Stop()來插入結束時間戳，並完成連續性/頻率的查詢：

void GpuTimer::Stop()
{
    GpuTimerInfo& info = m_Queries.back();
    m_pImmediateContext->End(info.disjointQuery.Get());
    m_pImmediateContext->End(info.stopQuery.Get());
    info.isStopped = true;
}

調用Stop()後，這時我們還不一定能夠拿到間隔。考慮到運行時的性能分析考慮的是多間隔求平均，我們可以接受延遲幾幀的回讀。爲此，我們可以使用TryGetTime()，嘗試對時間最久遠、仍未完成的查詢嘗試GPU回讀：

bool GpuTimer::GetQueryDataHelper(ID3D11DeviceContext* pContext, bool loopUntilDone, ID3D11Query* query, void* data, uint32_t dataSize)
{
    if (query == nullptr)
        return false;

    HRESULT hr = S_OK;
    int attempts = 0;
    do
    {
        // 嘗試GPU回讀
        hr = pContext->GetData(query, data, dataSize, 0);
        if (hr == S_OK)
            return true;
        attempts++;
        if (attempts > 100)
            Sleep(1);
        if (attempts > 1000)
        {
            assert(false);
            return false;
        }
    } while (loopUntilDone && (hr == S_FALSE));
    return false;

bool GpuTimer::TryGetTime(double* pOut)
{
    if (m_Queries.empty())
        return false;

    GpuTimerInfo& info = m_Queries.front();
    if (!info.isStopped) return false;
    if (info.disjointQuery && !GetQueryDataHelper(m_pImmediateContext.Get(), false, info.disjointQuery.Get(), &info.disjointData, sizeof(info.disjointData)))
        return false;
    info.disjointQuery.Reset();

    if (info.startQuery && !GetQueryDataHelper(m_pImmediateContext.Get(), false, info.startQuery.Get(), &info.startData, sizeof(info.startData)))
        return false;
    info.startQuery.Reset();

    if (info.stopQuery && !GetQueryDataHelper(m_pImmediateContext.Get(), false, info.stopQuery.Get(), &info.stopData, sizeof(info.stopData)))
        return false;
    info.stopQuery.Reset();

    if (!info.disjointData.Disjoint)
    {
        double deltaTime = static_cast<double>(info.stopData - info.startData) / info.disjointData.Frequency;
        if (m_RecentCount > 0)
            m_DeltaTimes.push_back(deltaTime);
        m_AccumTime += deltaTime;
        m_AccumCount++;
        if (m_DeltaTimes.size() > m_RecentCount)
        {
            m_AccumTime -= m_DeltaTimes.front();
            m_DeltaTimes.pop_front();
        }
        if (pOut) *pOut = deltaTime;
    }
    else
    {
        double deltaTime = -1.0;
    }

    m_Queries.pop_front();
    return true;
}

如果你就是在當前幀獲取間隔，可以使用GetTime()：

double GpuTimer::GetTime()
{
    if (m_Queries.empty())
        return -1.0;

    GpuTimerInfo& info = m_Queries.front();
    if (!info.isStopped) return -1.0;

    if (info.disjointQuery)
    {
        GetQueryDataHelper(m_pImmediateContext.Get(), true, info.disjointQuery.Get(), &info.disjointData, sizeof(info.disjointData));
        info.disjointQuery.Reset();
    }
    if (info.startQuery)
    {
        GetQueryDataHelper(m_pImmediateContext.Get(), true, info.startQuery.Get(), &info.startData, sizeof(info.startData));
        info.startQuery.Reset();
    }
    if (info.stopQuery)
    {
        GetQueryDataHelper(m_pImmediateContext.Get(), true, info.stopQuery.Get(), &info.stopData, sizeof(info.stopData));
        info.stopQuery.Reset();
    }

    double deltaTime = -1.0;
    if (!info.disjointData.Disjoint)
    {
        deltaTime = static_cast<double>(info.stopData - info.startData) / info.disjointData.Frequency;
        if (m_RecentCount > 0)
            m_DeltaTimes.push_back(deltaTime);
        m_AccumTime += deltaTime;
        m_AccumCount++;
        if (m_DeltaTimes.size() > m_RecentCount)
        {
            m_AccumTime -= m_DeltaTimes.front();
            m_DeltaTimes.pop_front();
        }
    }

    m_Queries.pop_front();
    return deltaTime;
}

重置GPU計時器的話使用Reset()方法：

void GpuTimer::Reset(ID3D11DeviceContext* deviceContext, size_t recentCount)
{
    m_Queries.clear();
    m_DeltaTimes.clear();
    m_pImmediateContext = deviceContext;
    m_AccumTime = 0.0;
    m_AccumCount = 0;
    if (recentCount)
        m_RecentCount = recentCount;
}

下面的代碼展示如何使用GPU計時器：

m_GpuTimer.Init(m_pd3dDevice.Get(), m_pd3dImmediateContext.Get());



// ...
m_GpuTimer.Start();
{
    // 一些繪製過程...
}
m_GpuTimer.Stop();

// ...
m_GpuTimer.TryGetTime(nullptr); // 只是爲了更新下面的平均值
float avgTime = m_GpuTimer.AverageTime();

下面是分塊延遲渲染統計各個pass用時的例子：

注意：如果遊戲開啓了垂直同步，那麼當前幀中的某一個查詢很可能會受到垂直同步的影響被拖長，從而導致原本當前幀GPU計時器的平均用時總和會接近兩個垂直同步信號的間隔。以下圖爲例

DirectX11 With Windows SDK完整目錄

歡迎加入QQ羣: 727623616 可以一起探討DX11，以及有什麼問題也可以在這裏彙報。

DirectX11--CPU與GPU計時器

前言

CPU計時器

GPU計時器

ID3D11Device::CreateQueue--創建GPU查詢

這個網絡爬蟲代碼，拿到數據之後如何存到csv文件中去？

即刻放大鏡。跟隨鼠標，屏幕任意位置放大

【面試準備】【SQL】數據庫有哪些約束？

.NET開源強大、易於使用的緩存框架 - FusionCache

面試，有時候是個運氣活

DirectX11 With Windows SDK--06 使用ImGui

DirectX11 With Windows SDK--19(Dev) 編譯Assimp並加載模型、新的Effects框架

DirectX11 With Windows SDK--40 抗鋸齒：FXAA

DirectX11--CPU與GPU計時器

DirectX11 With Windows SDK--39 陰影技術（VSM、ESM）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結