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