Page MenuHomeWildfire Games
Differential D721 Diff 19200 source/ps/Profiler2GPU.cpp

Changeset View

Standalone View

View Options

source/ps/Profiler2GPU.cpp

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprotected:
CProfiler2GPU_timer_query(CProfiler2& profiler, const char* name) : CProfiler2GPU_timer_query(CProfiler2& profiler, const char* name) :
CProfiler2GPU_base(profiler, name) CProfiler2GPU_base(profiler, name)
{ {
} }
~CProfiler2GPU_timer_query() ~CProfiler2GPU_timer_query()
{ {
if (!m_FreeQueries.empty()) if (!m_FreeQueries.empty())
pglDeleteQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]); glDeleteQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]);
ogl_WarnIfError(); ogl_WarnIfError();
} }
// Returns a new GL query object (or a recycled old one) // Returns a new GL query object (or a recycled old one)
GLuint NewQuery() GLuint NewQuery()
{ {
if (m_FreeQueries.empty()) if (m_FreeQueries.empty())
{ {
// Generate a batch of new queries // Generate a batch of new queries
m_FreeQueries.resize(8); m_FreeQueries.resize(8);
pglGenQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]); glGenQueriesARB(m_FreeQueries.size(), &m_FreeQueries[0]);
ogl_WarnIfError(); ogl_WarnIfError();
} }
GLuint query = m_FreeQueries.back(); GLuint query = m_FreeQueries.back();
m_FreeQueries.pop_back(); m_FreeQueries.pop_back();
return query; return query;
} }
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines void FrameStart()
const double RESYNC_PERIOD = 1.0; // seconds const double RESYNC_PERIOD = 1.0; // seconds
double now = m_Profiler.GetTime(); double now = m_Profiler.GetTime();
if (m_Frames.empty() || now > m_Frames.back().syncTimeStart + RESYNC_PERIOD) if (m_Frames.empty() || now > m_Frames.back().syncTimeStart + RESYNC_PERIOD)
{ {
PROFILE2("profile timestamp resync"); PROFILE2("profile timestamp resync");
pglGetInteger64v(GL_TIMESTAMP, &frame.syncTimestampStart); glGetInteger64v(GL_TIMESTAMP, &frame.syncTimestampStart);
ogl_WarnIfError(); ogl_WarnIfError();
frame.syncTimeStart = m_Profiler.GetTime(); frame.syncTimeStart = m_Profiler.GetTime();
// (Have to do GetTime again after GL_TIMESTAMP, because GL_TIMESTAMP // (Have to do GetTime again after GL_TIMESTAMP, because GL_TIMESTAMP
// might wait a while before returning its now-current timestamp) // might wait a while before returning its now-current timestamp)
} }
else else
{ {
Show All 17 Lines void RecordRegion(const char* id, bool isEnter)
ENSURE(!m_Frames.empty()); ENSURE(!m_Frames.empty());
SFrame& frame = m_Frames.back(); SFrame& frame = m_Frames.back();
SEvent event; SEvent event;
event.id = id; event.id = id;
event.query = NewQuery(); event.query = NewQuery();
event.isEnter = isEnter; event.isEnter = isEnter;
pglQueryCounter(event.query, GL_TIMESTAMP); glQueryCounter(event.query, GL_TIMESTAMP);
ogl_WarnIfError(); ogl_WarnIfError();
frame.events.push_back(event); frame.events.push_back(event);
} }
void RegionEnter(const char* id) void RegionEnter(const char* id)
{ {
RecordRegion(id, true); RecordRegion(id, true);
Show All 9 Linesprivate:
void ProcessFrames() void ProcessFrames()
{ {
while (!m_Frames.empty()) while (!m_Frames.empty())
{ {
SFrame& frame = m_Frames.front(); SFrame& frame = m_Frames.front();
// Queries become available in order so we only need to check the last one // Queries become available in order so we only need to check the last one
GLint available = 0; GLint available = 0;
pglGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available); glGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available);
ogl_WarnIfError(); ogl_WarnIfError();
if (!available) if (!available)
break; break;
// The frame's queries are now available, so retrieve and record all their results: // The frame's queries are now available, so retrieve and record all their results:
for (size_t i = 0; i < frame.events.size(); ++i) for (size_t i = 0; i < frame.events.size(); ++i)
{ {
GLuint64 queryTimestamp = 0; GLuint64 queryTimestamp = 0;
pglGetQueryObjectui64v(frame.events[i].query, GL_QUERY_RESULT, &queryTimestamp); glGetQueryObjectui64v(frame.events[i].query, GL_QUERY_RESULT, &queryTimestamp);
// (use the non-suffixed function here, as defined by GL_ARB_timer_query) // (use the non-suffixed function here, as defined by GL_ARB_timer_query)
ogl_WarnIfError(); ogl_WarnIfError();
// Convert to absolute CPU-clock time // Convert to absolute CPU-clock time
double t = frame.syncTimeStart + (double)(queryTimestamp - frame.syncTimestampStart) / 1e9; double t = frame.syncTimeStart + (double)(queryTimestamp - frame.syncTimestampStart) / 1e9;
// Record a frame-start for syncing // Record a frame-start for syncing
if (i == 0) if (i == 0)
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines void FrameStart()
RegionEnter("frame"); RegionEnter("frame");
} }
void FrameEnd() void FrameEnd()
{ {
RegionLeave("frame"); RegionLeave("frame");
pglEndQueryARB(GL_TIME_ELAPSED); glEndQueryARB(GL_TIME_ELAPSED);
ogl_WarnIfError(); ogl_WarnIfError();
} }
void RecordRegion(const char* id, bool isEnter) void RecordRegion(const char* id, bool isEnter)
{ {
ENSURE(!m_Frames.empty()); ENSURE(!m_Frames.empty());
SFrame& frame = m_Frames.back(); SFrame& frame = m_Frames.back();
// Must call glEndQuery before calling glGenQueries (via NewQuery), // Must call glEndQuery before calling glGenQueries (via NewQuery),
// for compatibility with the GL_EXT_timer_query spec (which says // for compatibility with the GL_EXT_timer_query spec (which says
// GL_INVALID_OPERATION if a query of any target is active; the ARB // GL_INVALID_OPERATION if a query of any target is active; the ARB
// spec and OpenGL specs don't appear to say that, but the AMD drivers // spec and OpenGL specs don't appear to say that, but the AMD drivers
// implement that error (see Trac #1033)) // implement that error (see Trac #1033))
if (!frame.events.empty()) if (!frame.events.empty())
{ {
pglEndQueryARB(GL_TIME_ELAPSED); glEndQueryARB(GL_TIME_ELAPSED);
ogl_WarnIfError(); ogl_WarnIfError();
} }
SEvent event; SEvent event;
event.id = id; event.id = id;
event.query = NewQuery(); event.query = NewQuery();
event.isEnter = isEnter; event.isEnter = isEnter;
pglBeginQueryARB(GL_TIME_ELAPSED, event.query); glBeginQueryARB(GL_TIME_ELAPSED, event.query);
ogl_WarnIfError(); ogl_WarnIfError();
frame.events.push_back(event); frame.events.push_back(event);
} }
void RegionEnter(const char* id) void RegionEnter(const char* id)
{ {
RecordRegion(id, true); RecordRegion(id, true);
} }
void RegionLeave(const char* id) void RegionLeave(const char* id)
{ {
RecordRegion(id, false); RecordRegion(id, false);
} }
private: private:
void ProcessFrames() void ProcessFrames()
{ {
while (!m_Frames.empty()) while (!m_Frames.empty())
{ {
SFrame& frame = m_Frames.front(); SFrame& frame = m_Frames.front();
// Queries become available in order so we only need to check the last one // Queries become available in order so we only need to check the last one
GLint available = 0; GLint available = 0;
pglGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available); glGetQueryObjectivARB(frame.events.back().query, GL_QUERY_RESULT_AVAILABLE, &available);
ogl_WarnIfError(); ogl_WarnIfError();
if (!available) if (!available)
break; break;
// The frame's queries are now available, so retrieve and record all their results: // The frame's queries are now available, so retrieve and record all their results:
double t = frame.timeStart; double t = frame.timeStart;
m_Storage.RecordFrameStart(t); m_Storage.RecordFrameStart(t);
for (size_t i = 0; i < frame.events.size(); ++i) for (size_t i = 0; i < frame.events.size(); ++i)
{ {
if (frame.events[i].isEnter) if (frame.events[i].isEnter)
m_Storage.Record(CProfiler2::ITEM_ENTER, t, frame.events[i].id); m_Storage.Record(CProfiler2::ITEM_ENTER, t, frame.events[i].id);
else else
m_Storage.RecordLeave(t); m_Storage.RecordLeave(t);
// Associate the frame number with the "frame" region // Associate the frame number with the "frame" region
if (i == 0) if (i == 0)
m_Storage.RecordAttributePrintf("%u", frame.num); m_Storage.RecordAttributePrintf("%u", frame.num);
// Advance by the elapsed time to the next event // Advance by the elapsed time to the next event
GLuint64 queryElapsed = 0; GLuint64 queryElapsed = 0;
pglGetQueryObjectui64vEXT(frame.events[i].query, GL_QUERY_RESULT, &queryElapsed); glGetQueryObjectui64vEXT(frame.events[i].query, GL_QUERY_RESULT, &queryElapsed);
// (use the EXT-suffixed function here, as defined by GL_EXT_timer_query) // (use the EXT-suffixed function here, as defined by GL_EXT_timer_query)
ogl_WarnIfError(); ogl_WarnIfError();
t += (double)queryElapsed / 1e9; t += (double)queryElapsed / 1e9;
} }
PopFrontFrame(); PopFrontFrame();
} }
} }
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesclass CProfiler2GPU_INTEL_performance_queries : public CProfiler2GPU_base
#define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT 0x9402 #define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT 0x9402
#define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT64 0x9403 #define INTEL_PERFQUERIES_TYPE_UNSIGNED_INT64 0x9403
#define INTEL_PERFQUERIES_TYPE_FLOAT 0x9404 #define INTEL_PERFQUERIES_TYPE_FLOAT 0x9404
#define INTEL_PERFQUERIES_TYPE_BOOL 0x9406 #define INTEL_PERFQUERIES_TYPE_BOOL 0x9406
public: public:
static bool IsSupported() static bool IsSupported()
{ {
return ogl_HaveExtension("GL_INTEL_performance_queries"); return ogl_HaveExtension("GL_INTEL_performance_queries");
leperUnsubmitted
Done
Inline Actions

Is this intended?

leper: Is this intended?
} }
CProfiler2GPU_INTEL_performance_queries(CProfiler2& profiler) : CProfiler2GPU_INTEL_performance_queries(CProfiler2& profiler) :
CProfiler2GPU_base(profiler, "gpu_intel") CProfiler2GPU_base(profiler, "gpu_intel")
{ {
LoadPerfCounters(); LoadPerfCounters();
} }
~CProfiler2GPU_INTEL_performance_queries() ~CProfiler2GPU_INTEL_performance_queries()
{ {
// Pop frames to return queries to the free list // Pop frames to return queries to the free list
while (!m_Frames.empty()) while (!m_Frames.empty())
PopFrontFrame(); PopFrontFrame();
for (size_t i = 0; i < m_QueryTypes.size(); ++i) for (size_t i = 0; i < m_QueryTypes.size(); ++i)
for (size_t j = 0; j < m_QueryTypes[i].freeQueries.size(); ++j) for (size_t j = 0; j < m_QueryTypes[i].freeQueries.size(); ++j)
pglDeletePerfQueryINTEL(m_QueryTypes[i].freeQueries[j]); glDeletePerfQueryINTEL(m_QueryTypes[i].freeQueries[j]);
ogl_WarnIfError(); ogl_WarnIfError();
} }
void FrameStart() void FrameStart()
{ {
ProcessFrames(); ProcessFrames();
Show All 18 Lines void RegionEnter(const char* id)
SEvent event; SEvent event;
event.id = id; event.id = id;
event.isEnter = true; event.isEnter = true;
for (size_t i = 0; i < m_QueryTypes.size(); ++i) for (size_t i = 0; i < m_QueryTypes.size(); ++i)
{ {
GLuint local_id = NewQuery(i); GLuint local_id = NewQuery(i);
pglBeginPerfQueryINTEL(local_id); glBeginPerfQueryINTEL(local_id);
ogl_WarnIfError(); ogl_WarnIfError();
event.queries.push_back(local_id); event.queries.push_back(local_id);
} }
frame.activeRegions.push_back(frame.events.size()); frame.activeRegions.push_back(frame.events.size());
frame.events.push_back(event); frame.events.push_back(event);
} }
void RegionLeave(const char* id) void RegionLeave(const char* id)
{ {
ENSURE(!m_Frames.empty()); ENSURE(!m_Frames.empty());
SFrame& frame = m_Frames.back(); SFrame& frame = m_Frames.back();
ENSURE(!frame.activeRegions.empty()); ENSURE(!frame.activeRegions.empty());
SEvent& activeEvent = frame.events[frame.activeRegions.back()]; SEvent& activeEvent = frame.events[frame.activeRegions.back()];
for (size_t i = 0; i < m_QueryTypes.size(); ++i) for (size_t i = 0; i < m_QueryTypes.size(); ++i)
{ {
pglEndPerfQueryINTEL(activeEvent.queries[i]); glEndPerfQueryINTEL(activeEvent.queries[i]);
ogl_WarnIfError(); ogl_WarnIfError();
} }
frame.activeRegions.pop_back(); frame.activeRegions.pop_back();
SEvent event; SEvent event;
event.id = id; event.id = id;
event.isEnter = false; event.isEnter = false;
frame.events.push_back(event); frame.events.push_back(event);
} }
private: private:
GLuint NewQuery(size_t queryIdx) GLuint NewQuery(size_t queryIdx)
{ {
ENSURE(queryIdx < m_QueryTypes.size()); ENSURE(queryIdx < m_QueryTypes.size());
if (m_QueryTypes[queryIdx].freeQueries.empty()) if (m_QueryTypes[queryIdx].freeQueries.empty())
{ {
GLuint id; GLuint id;
pglCreatePerfQueryINTEL(m_QueryTypes[queryIdx].queryTypeId, &id); glCreatePerfQueryINTEL(m_QueryTypes[queryIdx].queryTypeId, &id);
ogl_WarnIfError(); ogl_WarnIfError();
return id; return id;
} }
GLuint id = m_QueryTypes[queryIdx].freeQueries.back(); GLuint id = m_QueryTypes[queryIdx].freeQueries.back();
m_QueryTypes[queryIdx].freeQueries.pop_back(); m_QueryTypes[queryIdx].freeQueries.pop_back();
return id; return id;
} }
Show All 13 Lines while (!m_Frames.empty())
buffer.resize(size); buffer.resize(size);
for (size_t i = 0; i < frame.events.size(); ++i) for (size_t i = 0; i < frame.events.size(); ++i)
{ {
if (!frame.events[i].isEnter) if (!frame.events[i].isEnter)
continue; continue;
GLuint length = 0; GLuint length = 0;
pglGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_NONBLOCK, size, buffer.data(), &length); glGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_NONBLOCK, size, buffer.data(), &length);
ogl_WarnIfError(); ogl_WarnIfError();
if (length == 0) if (length == 0)
return; return;
} }
} }
double lastTime = frame.timeStart; double lastTime = frame.timeStart;
std::stack<double> endTimes; std::stack<double> endTimes;
Show All 10 Lines while (!m_Frames.empty())
m_Storage.RecordAttributePrintf("%u", frame.num); m_Storage.RecordAttributePrintf("%u", frame.num);
double elapsed = 0.0; double elapsed = 0.0;
for (size_t j = 0; j < m_QueryTypes.size(); ++j) for (size_t j = 0; j < m_QueryTypes.size(); ++j)
{ {
GLuint length; GLuint length;
buffer.resize(m_QueryTypes[j].counterBufferSize); buffer.resize(m_QueryTypes[j].counterBufferSize);
pglGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_BLOCK, m_QueryTypes[j].counterBufferSize, buffer.data(), &length); glGetPerfQueryDataINTEL(frame.events[i].queries[j], INTEL_PERFQUERIES_BLOCK, m_QueryTypes[j].counterBufferSize, buffer.data(), &length);
ogl_WarnIfError(); ogl_WarnIfError();
ENSURE(length == m_QueryTypes[j].counterBufferSize); ENSURE(length == m_QueryTypes[j].counterBufferSize);
m_Storage.RecordAttributePrintf("-- %s --", m_QueryTypes[j].name.c_str()); m_Storage.RecordAttributePrintf("-- %s --", m_QueryTypes[j].name.c_str());
for (size_t k = 0; k < m_QueryTypes[j].counters.size(); ++k) for (size_t k = 0; k < m_QueryTypes[j].counters.size(); ++k)
{ {
SPerfCounter& counter = m_QueryTypes[j].counters[k]; SPerfCounter& counter = m_QueryTypes[j].counters[k];
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines for (size_t i = 0; i < frame.events.size(); ++i)
for (size_t j = 0; j < m_QueryTypes.size(); ++j) for (size_t j = 0; j < m_QueryTypes.size(); ++j)
m_QueryTypes[j].freeQueries.push_back(frame.events[i].queries[j]); m_QueryTypes[j].freeQueries.push_back(frame.events[i].queries[j]);
m_Frames.pop_front(); m_Frames.pop_front();
} }
void LoadPerfCounters() void LoadPerfCounters()
{ {
GLuint queryTypeId; GLuint queryTypeId;
pglGetFirstPerfQueryIdINTEL(&queryTypeId); glGetFirstPerfQueryIdINTEL(&queryTypeId);
ogl_WarnIfError(); ogl_WarnIfError();
do do
{ {
char queryName[256]; char queryName[256];
GLuint counterBufferSize, numCounters, maxQueries, unknown; GLuint counterBufferSize, numCounters, maxQueries, unknown;
pglGetPerfQueryInfoINTEL(queryTypeId, ARRAY_SIZE(queryName), queryName, &counterBufferSize, &numCounters, &maxQueries, &unknown); glGetPerfQueryInfoINTEL(queryTypeId, ARRAY_SIZE(queryName), queryName, &counterBufferSize, &numCounters, &maxQueries, &unknown);
ogl_WarnIfError(); ogl_WarnIfError();
ENSURE(unknown == 1); ENSURE(unknown == 1);
SPerfQueryType query; SPerfQueryType query;
query.queryTypeId = queryTypeId; query.queryTypeId = queryTypeId;
query.name = queryName; query.name = queryName;
query.counterBufferSize = counterBufferSize; query.counterBufferSize = counterBufferSize;
for (GLuint counterId = 1; counterId <= numCounters; ++counterId) for (GLuint counterId = 1; counterId <= numCounters; ++counterId)
{ {
char counterName[256]; char counterName[256];
char counterDesc[2048]; char counterDesc[2048];
GLuint counterOffset, counterSize, counterUsage, counterType; GLuint counterOffset, counterSize, counterUsage, counterType;
GLuint64 unknown2; GLuint64 unknown2;
pglGetPerfCounterInfoINTEL(queryTypeId, counterId, ARRAY_SIZE(counterName), counterName, ARRAY_SIZE(counterDesc), counterDesc, &counterOffset, &counterSize, &counterUsage, &counterType, &unknown2); glGetPerfCounterInfoINTEL(queryTypeId, counterId, ARRAY_SIZE(counterName), counterName, ARRAY_SIZE(counterDesc), counterDesc, &counterOffset, &counterSize, &counterUsage, &counterType, &unknown2);
ogl_WarnIfError(); ogl_WarnIfError();
ENSURE(unknown2 == 0 || unknown2 == 1); ENSURE(unknown2 == 0 || unknown2 == 1);
SPerfCounter counter; SPerfCounter counter;
counter.name = counterName; counter.name = counterName;
counter.desc = counterDesc; counter.desc = counterDesc;
counter.offset = counterOffset; counter.offset = counterOffset;
counter.size = counterSize; counter.size = counterSize;
counter.type = counterType; counter.type = counterType;
query.counters.push_back(counter); query.counters.push_back(counter);
} }
m_QueryTypes.push_back(query); m_QueryTypes.push_back(query);
pglGetNextPerfQueryIdINTEL(queryTypeId, &queryTypeId); glGetNextPerfQueryIdINTEL(queryTypeId, &queryTypeId);
ogl_WarnIfError(); ogl_WarnIfError();
} while (queryTypeId); } while (queryTypeId);
} }
}; };
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines
Wildfire Games · Phabricator