static void
completeCallQuery(CallQuery& query) {
/* Get call start and duration */
int64_t gpuStart = 0, gpuDuration = 0, cpuDuration = 0, pixels = 0, vsizeDuration = 0, rssDuration = 0;
if (query.isDraw) {
if (retrace::profilingGpuTimes) {
if (supportsTimestamp) {
/* Use ARB queries in case EXT not present */
glGetQueryObjecti64v(query.ids[GPU_START], GL_QUERY_RESULT, &gpuStart);
glGetQueryObjecti64v(query.ids[GPU_DURATION], GL_QUERY_RESULT, &gpuDuration);
} else {
glGetQueryObjecti64vEXT(query.ids[GPU_DURATION], GL_QUERY_RESULT, &gpuDuration);
}
}
if (retrace::profilingPixelsDrawn) {
if (supportsTimestamp) {
glGetQueryObjecti64v(query.ids[OCCLUSION], GL_QUERY_RESULT, &pixels);
} else if (supportsElapsed) {
glGetQueryObjecti64vEXT(query.ids[OCCLUSION], GL_QUERY_RESULT, &pixels);
} else {
uint32_t pixels32;
glGetQueryObjectuiv(query.ids[OCCLUSION], GL_QUERY_RESULT, &pixels32);
pixels = static_cast<int64_t>(pixels32);
}
}
} else {
pixels = -1;
}
if (retrace::profilingCpuTimes) {
double cpuTimeScale = 1.0E9 / getTimeFrequency();
cpuDuration = (query.cpuEnd - query.cpuStart) * cpuTimeScale;
query.cpuStart *= cpuTimeScale;
}
if (retrace::profilingMemoryUsage) {
vsizeDuration = query.vsizeEnd - query.vsizeStart;
rssDuration = query.rssEnd - query.rssStart;
}
glDeleteQueries(NUM_QUERIES, query.ids);
/* Add call to profile */
retrace::profiler.addCall(query.call, query.sig->name, query.program, pixels, gpuStart, gpuDuration, query.cpuStart, cpuDuration, query.vsizeStart, vsizeDuration, query.rssStart, rssDuration);
}
// --------------------------------------------------------------------------------------------------------------------
void UntexturedObjectsGLBindlessIndirect::resolveQueries()
{
// Only happens the first time, and we don't need to resolve to move forward.
if (m_currentQueryGet == -1) {
m_currentQueryGet = 0;
return;
}
while (1) {
GLuint available = GL_FALSE;
glGetQueryObjectuiv(m_queries[m_currentQueryGet], GL_QUERY_RESULT_AVAILABLE, &available);
if (available == GL_FALSE && ((m_currentQueryIssue + 1) % kQueryCount) != m_currentQueryGet) {
// If we're not already overlapping, can just exit if the result is unavailable.
break;
}
GLint64 timeElapsed = 0;
glGetQueryObjecti64v(m_queries[m_currentQueryGet], GL_QUERY_RESULT, &timeElapsed);
console::debug("Elapsed GPU: %.2f ms\n", float(timeElapsed) / 1000000.0f);
m_currentQueryGet = (m_currentQueryGet + 1) % kQueryCount;
if (m_currentQueryGet == m_currentQueryIssue) {
break;
}
}
}
template<> Long AbstractQuery::result<Long>() {
Long result;
#ifndef MAGNUM_TARGET_GLES
glGetQueryObjecti64v(_id, GL_QUERY_RESULT, &result);
#elif !defined(CORRADE_TARGET_NACL)
glGetQueryObjecti64vEXT(_id, GL_QUERY_RESULT_EXT, &result);
#else
CORRADE_ASSERT_UNREACHABLE();
#endif
return result;
}
PIGLIT_GL_TEST_CONFIG_END
static GLint64
get_gpu_time_via_query(GLuint q)
{
GLint64 time;
glQueryCounter(q, GL_TIMESTAMP);
glGetQueryObjecti64v(q, GL_QUERY_RESULT, &time);
return time;
}
void MetricBackend_opengl::processQueries() {
int64_t gpuStart, gpuEnd, pixels;
for (int i = 0; i < QUERY_BOUNDARY_LIST_END; i++) {
QueryBoundary boundary = static_cast<QueryBoundary>(i);
while (!queries[i].empty()) {
auto &query = queries[i].front();
if (metrics[METRIC_GPU_START].profiled[i]) {
glGetQueryObjecti64v(query[QUERY_GPU_START], GL_QUERY_RESULT,
&gpuStart);
int64_t value = gpuStart - baseTime;
data[METRIC_GPU_START][i]->addData(boundary, value);
}
if (metrics[METRIC_GPU_DURATION].profiled[i]) {
if (supportsTimestamp) {
glGetQueryObjecti64v(query[QUERY_GPU_DURATION], GL_QUERY_RESULT,
&gpuEnd);
gpuEnd -= gpuStart;
} else {
glGetQueryObjecti64vEXT(query[QUERY_GPU_DURATION], GL_QUERY_RESULT,
&gpuEnd);
}
data[METRIC_GPU_DURATION][i]->addData(boundary, gpuEnd);
}
if (metrics[METRIC_GPU_PIXELS].profiled[i]) {
if (supportsTimestamp) {
glGetQueryObjecti64v(query[QUERY_OCCLUSION], GL_QUERY_RESULT, &pixels);
} else if (supportsElapsed) {
glGetQueryObjecti64vEXT(query[QUERY_OCCLUSION], GL_QUERY_RESULT, &pixels);
} else {
uint32_t pixels32;
glGetQueryObjectuiv(query[QUERY_OCCLUSION], GL_QUERY_RESULT, &pixels32);
pixels = static_cast<int64_t>(pixels32);
}
data[METRIC_GPU_PIXELS][i]->addData(boundary, pixels);
}
glDeleteQueries(QUERY_LIST_END, query.data());
queries[i].pop();
}
}
}
bool render()
{
glm::ivec2 WindowSize(this->getWindowSize());
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
glQueryCounter(QueryName[query::BEGIN], GL_TIMESTAMP);
glViewport(0, 0, WindowSize.x, WindowSize.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glUseProgram(ProgramName);
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glBindVertexArray(VertexArrayName);
glDrawArrays(GL_TRIANGLES, 0, VertexCount);
glQueryCounter(QueryName[query::END], GL_TIMESTAMP);
GLint AvailableBegin = GL_FALSE;
glGetQueryObjectiv(QueryName[query::BEGIN], GL_QUERY_RESULT_AVAILABLE, &AvailableBegin);
GLint AvailableEnd = GL_FALSE;
glGetQueryObjectiv(QueryName[query::END], GL_QUERY_RESULT_AVAILABLE, &AvailableEnd);
// The OpenGL implementations will wait for the query if it's not available
GLint64 TimeBegin = 0, TimeEnd = 0;
glGetQueryObjecti64v(QueryName[query::BEGIN], GL_QUERY_RESULT, &TimeBegin);
glGetQueryObjecti64v(QueryName[query::END], GL_QUERY_RESULT, &TimeEnd);
//glGetInteger64v(GL_TIMESTAMP, &TimeBegin);
//glGetInteger64v(GL_TIMESTAMP, &TimeEnd);
fprintf(stdout, "%d, %d / Time stamp: %f ms \r", AvailableBegin, AvailableEnd, (TimeEnd - TimeBegin) / 1000.f / 1000.f);
return TimeEnd - TimeBegin > 0;
}
template<> Long AbstractQuery::result<Long>() {
CORRADE_ASSERT(!target, "AbstractQuery::result(): the query is currently running", {});
/** @todo Re-enable when extension loader is available for ES */
Long result;
#ifndef MAGNUM_TARGET_GLES
glGetQueryObjecti64v(_id, GL_QUERY_RESULT, &result);
#else
CORRADE_INTERNAL_ASSERT(false);
//glGetQueryObjecti64vEXT(_id, GL_QUERY_RESULT, &result);
#endif
return result;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL33_nglGetQueryObjecti64v(JNIEnv *__env, jclass clazz, jint id, jint pname, jlong paramsAddress, jlong __functionAddress) {
GLint64 *params = (GLint64 *)(intptr_t)paramsAddress;
glGetQueryObjecti64vPROC glGetQueryObjecti64v = (glGetQueryObjecti64vPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glGetQueryObjecti64v(id, pname, params);
}
GLint64 Query::getValueInt64() const
{
GLint64 value = 0;
glGetQueryObjecti64v( mId, GL_QUERY_RESULT, &value );
return value;
}
void base::app::process_captured_screen()
{
while(_rb_tail != _rb_head) {
const int screen_size =
get_wnd_width()
* get_wnd_height()
* base::get_pfd(CAPTURE_PF)->_size;
const int tmp_tail = (_rb_tail + 1) & RB_BUFFERS_MASK;
screen_buffer *sc = _screen_buffers_rb + tmp_tail;
GLenum res = glClientWaitSync(sc->_fence, 0, 0);
if(res == GL_ALREADY_SIGNALED || res == GL_CONDITION_SATISFIED) { // AMD returns GL_CONDITION_SATISFIED only BUG?
glDeleteSync(sc->_fence);
_timer.start();
if(base::cfg().use_pinned_memory) {
// process data
//memcpy(ptr_dst, sc->_pinned_ptr_aligned, screen_size);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, sc->_buffer);
}
else {
glBindBuffer(GL_COPY_READ_BUFFER, sc->_buffer);
/*glBindBuffer(GL_PIXEL_UNPACK_BUFFER, sc->_showtime_buffer);
char *ptr_dst = reinterpret_cast<char*>(
glMapBufferRange(
GL_PIXEL_UNPACK_BUFFER,
0,
screen_size,
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT));*/
char *ptr_src = reinterpret_cast<char*>(
glMapBufferRange(
GL_COPY_READ_BUFFER,
0,
screen_size,
GL_MAP_READ_BIT));
//memcpy(ptr_dst, ptr_src, screen_size);
glUnmapBuffer(GL_COPY_READ_BUFFER);
//glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
}
glBindTexture(GL_TEXTURE_2D, _showtime_tex);
glTexImage2D(
GL_TEXTURE_2D,
0,
base::get_pfd(CAPTURE_PF)->_internal,
get_wnd_width(),
get_wnd_height(),
0,
base::get_pfd(CAPTURE_PF)->_format,
base::get_pfd(CAPTURE_PF)->_type,
0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
const double map_time = _timer.elapsed_time();
__int64 result[3]={0,};
glGetQueryObjecti64v(sc->_queries[2], GL_QUERY_RESULT, result + 2);
glGetQueryObjecti64v(sc->_queries[1], GL_QUERY_RESULT, result + 1);
glGetQueryObjecti64v(sc->_queries[0], GL_QUERY_RESULT, result);
const double coef_n2m = 1.0 / 1000000.0;
const double time0 = double(result[1] - result[0]) * coef_n2m;
const double time1 = double(result[2] - result[1]) * coef_n2m;
static int counter = 0;
if((counter++ % 64) == 0) {
printf("read %.2f ms / %.2f GB/s copy: %.2f ms / %.2f GB/s lag: %u map: %.2f ms / %.2f GB/s\n",
time0,
(double(screen_size) / time0) * (1.0 / double(0x100000)),
time1,
time1 > 0.01 ? (double(screen_size) / time1) * (1.0 / double(0x100000)) : 0.0,
_frame_number - sc->_frame_num,
map_time,
map_time > 0.01 ? (double(screen_size) / map_time) * (1.0 / double(0x100000)) : 0.0);
}
_rb_tail = tmp_tail;
}
else {
break;
}
}
}
