mirror of
https://github.com/wolfpld/tracy.git
synced 2024-11-10 02:31:48 +00:00
b0fc0d5dcc
The C++11 spec states in [basic.stc.thread] thread storage duration: 2. A variable with thread storage duration shall be initialized before its first odr-use (3.2) and, if constructed, shall be destroyed on thread exit. Previously Tracy relied on the TLS data being initialized: - During thread creation (MSVC). - Or during first use in a thread, but the initialization was performed for the whole TLS block. It seems that new compilers are more granular with how they perform the initialization, hence rpmalloc init has to be checked before each allocation, as it cannot be "folded" into, for example, initialization of the profiler itself.
509 lines
19 KiB
C++
509 lines
19 KiB
C++
#ifndef __TRACYD3D12_HPP__
|
|
#define __TRACYD3D12_HPP__
|
|
|
|
#ifndef TRACY_ENABLE
|
|
|
|
#define TracyD3D12Context(device, queue) nullptr
|
|
#define TracyD3D12Destroy(ctx)
|
|
#define TracyD3D12ContextName(ctx, name, size)
|
|
|
|
#define TracyD3D12NewFrame(ctx)
|
|
|
|
#define TracyD3D12Zone(ctx, cmdList, name)
|
|
#define TracyD3D12ZoneC(ctx, cmdList, name, color)
|
|
#define TracyD3D12NamedZone(ctx, varname, cmdList, name, active)
|
|
#define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active)
|
|
#define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active)
|
|
|
|
#define TracyD3D12ZoneS(ctx, cmdList, name, depth)
|
|
#define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth)
|
|
#define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active)
|
|
#define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active)
|
|
#define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active)
|
|
|
|
#define TracyD3D12Collect(ctx)
|
|
|
|
namespace tracy
|
|
{
|
|
class D3D12ZoneScope {};
|
|
}
|
|
|
|
using TracyD3D12Ctx = void*;
|
|
|
|
#else
|
|
|
|
#include "Tracy.hpp"
|
|
#include "client/TracyProfiler.hpp"
|
|
#include "client/TracyCallstack.hpp"
|
|
|
|
#include <cstdlib>
|
|
#include <cassert>
|
|
#include <d3d12.h>
|
|
#include <dxgi.h>
|
|
#include <wrl/client.h>
|
|
#include <queue>
|
|
|
|
namespace tracy
|
|
{
|
|
|
|
struct D3D12QueryPayload
|
|
{
|
|
uint32_t m_queryIdStart = 0;
|
|
uint32_t m_queryCount = 0;
|
|
};
|
|
|
|
// Command queue context.
|
|
class D3D12QueueCtx
|
|
{
|
|
friend class D3D12ZoneScope;
|
|
|
|
static constexpr uint32_t MaxQueries = 64 * 1024; // Queries are begin and end markers, so we can store half as many total time durations. Must be even!
|
|
|
|
bool m_initialized = false;
|
|
|
|
ID3D12Device* m_device = nullptr;
|
|
ID3D12CommandQueue* m_queue = nullptr;
|
|
uint8_t m_context;
|
|
Microsoft::WRL::ComPtr<ID3D12QueryHeap> m_queryHeap;
|
|
Microsoft::WRL::ComPtr<ID3D12Resource> m_readbackBuffer;
|
|
|
|
// In-progress payload.
|
|
uint32_t m_queryLimit = MaxQueries;
|
|
uint32_t m_queryCounter = 0;
|
|
uint32_t m_previousQueryCounter = 0;
|
|
|
|
uint32_t m_activePayload = 0;
|
|
Microsoft::WRL::ComPtr<ID3D12Fence> m_payloadFence;
|
|
std::queue<D3D12QueryPayload> m_payloadQueue;
|
|
|
|
int64_t m_prevCalibration = 0;
|
|
int64_t m_qpcToNs = int64_t{ 1000000000 / GetFrequencyQpc() };
|
|
|
|
public:
|
|
D3D12QueueCtx(ID3D12Device* device, ID3D12CommandQueue* queue)
|
|
: m_device(device)
|
|
, m_queue(queue)
|
|
, m_context(GetGpuCtxCounter().fetch_add(1, std::memory_order_relaxed))
|
|
{
|
|
// Verify we support timestamp queries on this queue.
|
|
|
|
if (queue->GetDesc().Type == D3D12_COMMAND_LIST_TYPE_COPY)
|
|
{
|
|
D3D12_FEATURE_DATA_D3D12_OPTIONS3 featureData{};
|
|
|
|
if (FAILED(device->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS3, &featureData, sizeof(featureData))))
|
|
{
|
|
assert(false && "Platform does not support profiling of copy queues.");
|
|
}
|
|
}
|
|
|
|
uint64_t timestampFrequency;
|
|
|
|
if (FAILED(queue->GetTimestampFrequency(×tampFrequency)))
|
|
{
|
|
assert(false && "Failed to get timestamp frequency.");
|
|
}
|
|
|
|
uint64_t cpuTimestamp;
|
|
uint64_t gpuTimestamp;
|
|
|
|
if (FAILED(queue->GetClockCalibration(&gpuTimestamp, &cpuTimestamp)))
|
|
{
|
|
assert(false && "Failed to get queue clock calibration.");
|
|
}
|
|
|
|
// Save the device cpu timestamp, not the profiler's timestamp.
|
|
m_prevCalibration = cpuTimestamp * m_qpcToNs;
|
|
|
|
cpuTimestamp = Profiler::GetTime();
|
|
|
|
D3D12_QUERY_HEAP_DESC heapDesc{};
|
|
heapDesc.Type = queue->GetDesc().Type == D3D12_COMMAND_LIST_TYPE_COPY ? D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP : D3D12_QUERY_HEAP_TYPE_TIMESTAMP;
|
|
heapDesc.Count = m_queryLimit;
|
|
heapDesc.NodeMask = 0; // #TODO: Support multiple adapters.
|
|
|
|
while (FAILED(device->CreateQueryHeap(&heapDesc, IID_PPV_ARGS(&m_queryHeap))))
|
|
{
|
|
m_queryLimit /= 2;
|
|
heapDesc.Count = m_queryLimit;
|
|
}
|
|
|
|
// Create a readback buffer, which will be used as a destination for the query data.
|
|
|
|
D3D12_RESOURCE_DESC readbackBufferDesc{};
|
|
readbackBufferDesc.Alignment = 0;
|
|
readbackBufferDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
|
|
readbackBufferDesc.Width = m_queryLimit * sizeof(uint64_t);
|
|
readbackBufferDesc.Height = 1;
|
|
readbackBufferDesc.DepthOrArraySize = 1;
|
|
readbackBufferDesc.Format = DXGI_FORMAT_UNKNOWN;
|
|
readbackBufferDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; // Buffers are always row major.
|
|
readbackBufferDesc.MipLevels = 1;
|
|
readbackBufferDesc.SampleDesc.Count = 1;
|
|
readbackBufferDesc.SampleDesc.Quality = 0;
|
|
readbackBufferDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
|
|
|
|
D3D12_HEAP_PROPERTIES readbackHeapProps{};
|
|
readbackHeapProps.Type = D3D12_HEAP_TYPE_READBACK;
|
|
readbackHeapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
|
|
readbackHeapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
|
|
readbackHeapProps.CreationNodeMask = 0;
|
|
readbackHeapProps.VisibleNodeMask = 0; // #TODO: Support multiple adapters.
|
|
|
|
if (FAILED(device->CreateCommittedResource(&readbackHeapProps, D3D12_HEAP_FLAG_NONE, &readbackBufferDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_readbackBuffer))))
|
|
{
|
|
assert(false && "Failed to create query readback buffer.");
|
|
}
|
|
|
|
if (FAILED(device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&m_payloadFence))))
|
|
{
|
|
assert(false && "Failed to create payload fence.");
|
|
}
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuNewContext);
|
|
MemWrite(&item->gpuNewContext.cpuTime, cpuTimestamp);
|
|
MemWrite(&item->gpuNewContext.gpuTime, gpuTimestamp);
|
|
memset(&item->gpuNewContext.thread, 0, sizeof(item->gpuNewContext.thread));
|
|
MemWrite(&item->gpuNewContext.period, 1E+09f / static_cast<float>(timestampFrequency));
|
|
MemWrite(&item->gpuNewContext.context, m_context);
|
|
MemWrite(&item->gpuNewContext.flags, GpuContextCalibration);
|
|
MemWrite(&item->gpuNewContext.type, GpuContextType::Direct3D12);
|
|
|
|
#ifdef TRACY_ON_DEMAND
|
|
GetProfiler().DeferItem(*item);
|
|
#endif
|
|
|
|
Profiler::QueueSerialFinish();
|
|
|
|
m_initialized = true;
|
|
}
|
|
|
|
void NewFrame()
|
|
{
|
|
m_payloadQueue.emplace(D3D12QueryPayload{ m_previousQueryCounter, m_queryCounter });
|
|
m_previousQueryCounter += m_queryCounter;
|
|
m_queryCounter = 0;
|
|
|
|
if (m_previousQueryCounter >= m_queryLimit)
|
|
{
|
|
m_previousQueryCounter -= m_queryLimit;
|
|
}
|
|
|
|
m_queue->Signal(m_payloadFence.Get(), ++m_activePayload);
|
|
}
|
|
|
|
void Name( const char* name, uint16_t len )
|
|
{
|
|
auto ptr = (char*)tracy_malloc( len );
|
|
memcpy( ptr, name, len );
|
|
|
|
auto item = Profiler::QueueSerial();
|
|
MemWrite( &item->hdr.type, QueueType::GpuContextName );
|
|
MemWrite( &item->gpuContextNameFat.context, m_context );
|
|
MemWrite( &item->gpuContextNameFat.ptr, (uint64_t)ptr );
|
|
MemWrite( &item->gpuContextNameFat.size, len );
|
|
#ifdef TRACY_ON_DEMAND
|
|
GetProfiler().DeferItem( *item );
|
|
#endif
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
void Collect()
|
|
{
|
|
ZoneScopedC(Color::Red4);
|
|
|
|
#ifdef TRACY_ON_DEMAND
|
|
if (!GetProfiler().IsConnected())
|
|
{
|
|
m_queryCounter = 0;
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// Find out what payloads are available.
|
|
const auto newestReadyPayload = m_payloadFence->GetCompletedValue();
|
|
const auto payloadCount = m_payloadQueue.size() - (m_activePayload - newestReadyPayload);
|
|
|
|
if (!payloadCount)
|
|
{
|
|
return; // No payloads are available yet, exit out.
|
|
}
|
|
|
|
D3D12_RANGE mapRange{ 0, m_queryLimit * sizeof(uint64_t) };
|
|
|
|
// Map the readback buffer so we can fetch the query data from the GPU.
|
|
void* readbackBufferMapping = nullptr;
|
|
|
|
if (FAILED(m_readbackBuffer->Map(0, &mapRange, &readbackBufferMapping)))
|
|
{
|
|
assert(false && "Failed to map readback buffer.");
|
|
}
|
|
|
|
auto* timestampData = static_cast<uint64_t*>(readbackBufferMapping);
|
|
|
|
for (uint32_t i = 0; i < payloadCount; ++i)
|
|
{
|
|
const auto& payload = m_payloadQueue.front();
|
|
|
|
for (uint32_t j = 0; j < payload.m_queryCount; ++j)
|
|
{
|
|
const auto counter = (payload.m_queryIdStart + j) % m_queryLimit;
|
|
const auto timestamp = timestampData[counter];
|
|
const auto queryId = counter;
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuTime);
|
|
MemWrite(&item->gpuTime.gpuTime, timestamp);
|
|
MemWrite(&item->gpuTime.queryId, static_cast<uint16_t>(queryId));
|
|
MemWrite(&item->gpuTime.context, m_context);
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
m_payloadQueue.pop();
|
|
}
|
|
|
|
m_readbackBuffer->Unmap(0, nullptr);
|
|
|
|
// Recalibrate to account for drift.
|
|
|
|
uint64_t cpuTimestamp;
|
|
uint64_t gpuTimestamp;
|
|
|
|
if (FAILED(m_queue->GetClockCalibration(&gpuTimestamp, &cpuTimestamp)))
|
|
{
|
|
assert(false && "Failed to get queue clock calibration.");
|
|
}
|
|
|
|
cpuTimestamp *= m_qpcToNs;
|
|
|
|
const auto cpuDelta = cpuTimestamp - m_prevCalibration;
|
|
if (cpuDelta > 0)
|
|
{
|
|
m_prevCalibration = cpuTimestamp;
|
|
cpuTimestamp = Profiler::GetTime();
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuCalibration);
|
|
MemWrite(&item->gpuCalibration.gpuTime, gpuTimestamp);
|
|
MemWrite(&item->gpuCalibration.cpuTime, cpuTimestamp);
|
|
MemWrite(&item->gpuCalibration.cpuDelta, cpuDelta);
|
|
MemWrite(&item->gpuCalibration.context, m_context);
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
}
|
|
|
|
private:
|
|
tracy_force_inline uint32_t NextQueryId()
|
|
{
|
|
assert(m_queryCounter < m_queryLimit && "Submitted too many GPU queries! Consider increasing MaxQueries.");
|
|
|
|
const uint32_t id = (m_previousQueryCounter + m_queryCounter) % m_queryLimit;
|
|
m_queryCounter += 2; // Allocate space for a begin and end query.
|
|
|
|
return id;
|
|
}
|
|
|
|
tracy_force_inline uint8_t GetId() const
|
|
{
|
|
return m_context;
|
|
}
|
|
};
|
|
|
|
class D3D12ZoneScope
|
|
{
|
|
const bool m_active;
|
|
D3D12QueueCtx* m_ctx = nullptr;
|
|
ID3D12GraphicsCommandList* m_cmdList = nullptr;
|
|
uint32_t m_queryId = 0; // Used for tracking in nested zones.
|
|
|
|
public:
|
|
tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, ID3D12GraphicsCommandList* cmdList, const SourceLocationData* srcLocation, bool active)
|
|
#ifdef TRACY_ON_DEMAND
|
|
: m_active(active && GetProfiler().IsConnected())
|
|
#else
|
|
: m_active(active)
|
|
#endif
|
|
{
|
|
if (!m_active) return;
|
|
|
|
m_ctx = ctx;
|
|
m_cmdList = cmdList;
|
|
|
|
m_queryId = ctx->NextQueryId();
|
|
cmdList->EndQuery(ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, m_queryId);
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuZoneBeginSerial);
|
|
MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime());
|
|
MemWrite(&item->gpuZoneBegin.srcloc, reinterpret_cast<uint64_t>(srcLocation));
|
|
MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle());
|
|
MemWrite(&item->gpuZoneBegin.queryId, static_cast<uint16_t>(m_queryId));
|
|
MemWrite(&item->gpuZoneBegin.context, ctx->GetId());
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, ID3D12GraphicsCommandList* cmdList, const SourceLocationData* srcLocation, int depth, bool active)
|
|
#ifdef TRACY_ON_DEMAND
|
|
: m_active(active&& GetProfiler().IsConnected())
|
|
#else
|
|
: m_active(active)
|
|
#endif
|
|
{
|
|
if (!m_active) return;
|
|
|
|
m_ctx = ctx;
|
|
m_cmdList = cmdList;
|
|
|
|
m_queryId = ctx->NextQueryId();
|
|
cmdList->EndQuery(ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, m_queryId);
|
|
|
|
auto* item = Profiler::QueueSerialCallstack(Callstack(depth));
|
|
MemWrite(&item->hdr.type, QueueType::GpuZoneBeginCallstackSerial);
|
|
MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime());
|
|
MemWrite(&item->gpuZoneBegin.srcloc, reinterpret_cast<uint64_t>(srcLocation));
|
|
MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle());
|
|
MemWrite(&item->gpuZoneBegin.queryId, static_cast<uint16_t>(m_queryId));
|
|
MemWrite(&item->gpuZoneBegin.context, ctx->GetId());
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, ID3D12GraphicsCommandList* cmdList, bool active)
|
|
#ifdef TRACY_ON_DEMAND
|
|
: m_active(active&& GetProfiler().IsConnected())
|
|
#else
|
|
: m_active(active)
|
|
#endif
|
|
{
|
|
if (!m_active) return;
|
|
|
|
m_ctx = ctx;
|
|
m_cmdList = cmdList;
|
|
|
|
m_queryId = ctx->NextQueryId();
|
|
cmdList->EndQuery(ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, m_queryId);
|
|
|
|
const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz);
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocSerial);
|
|
MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime());
|
|
MemWrite(&item->gpuZoneBegin.srcloc, sourceLocation);
|
|
MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle());
|
|
MemWrite(&item->gpuZoneBegin.queryId, static_cast<uint16_t>(m_queryId));
|
|
MemWrite(&item->gpuZoneBegin.context, ctx->GetId());
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
tracy_force_inline D3D12ZoneScope(D3D12QueueCtx* ctx, uint32_t line, const char* source, size_t sourceSz, const char* function, size_t functionSz, const char* name, size_t nameSz, ID3D12GraphicsCommandList* cmdList, int depth, bool active)
|
|
#ifdef TRACY_ON_DEMAND
|
|
: m_active(active&& GetProfiler().IsConnected())
|
|
#else
|
|
: m_active(active)
|
|
#endif
|
|
{
|
|
if (!m_active) return;
|
|
|
|
m_ctx = ctx;
|
|
m_cmdList = cmdList;
|
|
|
|
m_queryId = ctx->NextQueryId();
|
|
cmdList->EndQuery(ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, m_queryId);
|
|
|
|
const auto sourceLocation = Profiler::AllocSourceLocation(line, source, sourceSz, function, functionSz, name, nameSz);
|
|
|
|
auto* item = Profiler::QueueSerialCallstack(Callstack(depth));
|
|
MemWrite(&item->hdr.type, QueueType::GpuZoneBeginAllocSrcLocCallstackSerial);
|
|
MemWrite(&item->gpuZoneBegin.cpuTime, Profiler::GetTime());
|
|
MemWrite(&item->gpuZoneBegin.srcloc, sourceLocation);
|
|
MemWrite(&item->gpuZoneBegin.thread, GetThreadHandle());
|
|
MemWrite(&item->gpuZoneBegin.queryId, static_cast<uint16_t>(m_queryId));
|
|
MemWrite(&item->gpuZoneBegin.context, ctx->GetId());
|
|
|
|
Profiler::QueueSerialFinish();
|
|
}
|
|
|
|
tracy_force_inline ~D3D12ZoneScope()
|
|
{
|
|
if (!m_active) return;
|
|
|
|
const auto queryId = m_queryId + 1; // Our end query slot is immediately after the begin slot.
|
|
m_cmdList->EndQuery(m_ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, queryId);
|
|
|
|
auto* item = Profiler::QueueSerial();
|
|
MemWrite(&item->hdr.type, QueueType::GpuZoneEndSerial);
|
|
MemWrite(&item->gpuZoneEnd.cpuTime, Profiler::GetTime());
|
|
MemWrite(&item->gpuZoneEnd.thread, GetThreadHandle());
|
|
MemWrite(&item->gpuZoneEnd.queryId, static_cast<uint16_t>(queryId));
|
|
MemWrite(&item->gpuZoneEnd.context, m_ctx->GetId());
|
|
|
|
Profiler::QueueSerialFinish();
|
|
|
|
m_cmdList->ResolveQueryData(m_ctx->m_queryHeap.Get(), D3D12_QUERY_TYPE_TIMESTAMP, m_queryId, 2, m_ctx->m_readbackBuffer.Get(), m_queryId * sizeof(uint64_t));
|
|
}
|
|
};
|
|
|
|
static inline D3D12QueueCtx* CreateD3D12Context(ID3D12Device* device, ID3D12CommandQueue* queue)
|
|
{
|
|
auto* ctx = static_cast<D3D12QueueCtx*>(tracy_malloc(sizeof(D3D12QueueCtx)));
|
|
new (ctx) D3D12QueueCtx{ device, queue };
|
|
|
|
return ctx;
|
|
}
|
|
|
|
static inline void DestroyD3D12Context(D3D12QueueCtx* ctx)
|
|
{
|
|
ctx->~D3D12QueueCtx();
|
|
tracy_free(ctx);
|
|
}
|
|
|
|
}
|
|
|
|
using TracyD3D12Ctx = tracy::D3D12QueueCtx*;
|
|
|
|
#define TracyD3D12Context(device, queue) tracy::CreateD3D12Context(device, queue);
|
|
#define TracyD3D12Destroy(ctx) tracy::DestroyD3D12Context(ctx);
|
|
#define TracyD3D12ContextName(ctx, name, size) ctx->Name(name, size);
|
|
|
|
#define TracyD3D12NewFrame(ctx) ctx->NewFrame();
|
|
|
|
#if defined TRACY_HAS_CALLSTACK && defined TRACY_CALLSTACK
|
|
# define TracyD3D12Zone(ctx, cmdList, name) TracyD3D12NamedZoneS(ctx, ___tracy_gpu_zone, cmdList, name, TRACY_CALLSTACK, true)
|
|
# define TracyD3D12ZoneC(ctx, cmdList, name, color) TracyD3D12NamedZoneCS(ctx, ___tracy_gpu_zone, cmdList, name, color, TRACY_CALLSTACK, true)
|
|
# define TracyD3D12NamedZone(ctx, varname, cmdList, name, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), TRACY_CALLSTACK, active };
|
|
# define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, color }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), TRACY_CALLSTACK, active };
|
|
# define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, TRACY_CALLSTACK, active)
|
|
#else
|
|
# define TracyD3D12Zone(ctx, cmdList, name) TracyD3D12NamedZone(ctx, ___tracy_gpu_zone, cmdList, name, true)
|
|
# define TracyD3D12ZoneC(ctx, cmdList, name, color) TracyD3D12NamedZoneC(ctx, ___tracy_gpu_zone, cmdList, name, color, true)
|
|
# define TracyD3D12NamedZone(ctx, varname, cmdList, name, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), active };
|
|
# define TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, color }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), active };
|
|
# define TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active) tracy::D3D12ZoneScope varname{ ctx, __LINE__, __FILE__, strlen(__FILE__), __FUNCTION__, strlen(__FUNCTION__), name, strlen(name), cmdList, active };
|
|
#endif
|
|
|
|
#ifdef TRACY_HAS_CALLSTACK
|
|
# define TracyD3D12ZoneS(ctx, cmdList, name, depth) TracyD3D12NamedZoneS(ctx, ___tracy_gpu_zone, cmdList, name, depth, true)
|
|
# define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth) TracyD3D12NamedZoneCS(ctx, ___tracy_gpu_zone, cmdList, name, color, depth, true)
|
|
# define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, 0 }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), depth, active };
|
|
# define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active) static constexpr tracy::SourceLocationData TracyConcat(__tracy_gpu_source_location, __LINE__) { name, __FUNCTION__, __FILE__, (uint32_t)__LINE__, color }; tracy::D3D12ZoneScope varname{ ctx, cmdList, &TracyConcat(__tracy_gpu_source_location, __LINE__), depth, active };
|
|
# define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active) tracy::D3D12ZoneScope varname{ ctx, __LINE__, __FILE__, strlen(__FILE__), __FUNCTION__, strlen(__FUNCTION__), name, strlen(name), cmdList, depth, active };
|
|
#else
|
|
# define TracyD3D12ZoneS(ctx, cmdList, name, depth) TracyD3D12Zone(ctx, cmdList, name)
|
|
# define TracyD3D12ZoneCS(ctx, cmdList, name, color, depth) TracyD3D12Zone(ctx, cmdList, name, color)
|
|
# define TracyD3D12NamedZoneS(ctx, varname, cmdList, name, depth, active) TracyD3D12NamedZone(ctx, varname, cmdList, name, active)
|
|
# define TracyD3D12NamedZoneCS(ctx, varname, cmdList, name, color, depth, active) TracyD3D12NamedZoneC(ctx, varname, cmdList, name, color, active)
|
|
# define TracyD3D12ZoneTransientS(ctx, varname, cmdList, name, depth, active) TracyD3D12ZoneTransient(ctx, varname, cmdList, name, active)
|
|
#endif
|
|
|
|
#define TracyD3D12Collect(ctx) ctx->Collect();
|
|
|
|
#endif
|
|
|
|
#endif
|