bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 32; return Validated && this->checkError("initQuery"); }
Timer::Timer(bool timeGPU) : d_id(0), d_CPUtime(0), d_startCPUtime(chrono::steady_clock::now()), d_GPUtime(0), d_running(false) { if(timeGPU && GLEW_ARB_timer_query) glGenQueries(1, &d_id); }
enum piglit_result piglit_display(void) { #define NUM_QUERIES 5 GLuint queries[NUM_QUERIES], available; bool test_pass = true; GLint result; int i; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glClearColor(1.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glGenQueries(NUM_QUERIES, queries); glColor4f(0.0f, 1.0f, 0.0f, 1.0f); /* Queue up a bunch of drawing with several queries. */ for (i = 0; i < NUM_QUERIES - 1; i++) { glBeginQuery(GL_SAMPLES_PASSED, queries[i]); draw_some_things((double)i / (NUM_QUERIES - 1)); glEndQuery(GL_SAMPLES_PASSED); } /* Now fire off a query with no drawing. */ glBeginQuery(GL_SAMPLES_PASSED, queries[NUM_QUERIES - 1]); glEndQuery(GL_SAMPLES_PASSED); /* Get the result for the final query. */ glGetQueryObjectiv(queries[NUM_QUERIES - 1], GL_QUERY_RESULT, &result); /* At this point, the results of all the previous queries * should be available. */ for (i = 0; i < NUM_QUERIES - 1; i++) { glGetQueryObjectuiv(queries[i], GL_QUERY_RESULT_AVAILABLE, &available); if (available != 1) { printf("Query #%d result not available (expected in-order processing)\n", i); test_pass = false; } } glDeleteQueries(NUM_QUERIES, queries); piglit_present_results(); return test_pass ? PIGLIT_PASS : PIGLIT_FAIL; }
bool initQuery() { int QueryBits(0); glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 30; if(Validated) glGenQueries(static_cast<GLsizei>(QueryName.size()), &QueryName[0]); return Validated && this->checkError("initQuery"); }
bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 1; return Validated && this->checkError("initQuery"); }
bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 1; return Validated; }
//------------------------------------------------------------------------------ static void initGL() { glClearColor(0.1f, 0.1f, 0.1f, 0.0f); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glCullFace(GL_BACK); glEnable(GL_CULL_FACE); glGenQueries(2, g_queries); }
void piglit_init(int argc, char **argv) { int i; const struct test_set *test = NULL; GLuint prog, vs, gs, vao, xfb_buf; char *gs_text; bool pass = true; /* Parse params */ if (argc != 2) print_usage_and_exit(argv[0]); for (i = 0; i < ARRAY_SIZE(tests); i++) { if (strcmp(argv[1], tests[i].name) == 0) { test = &tests[i]; break; } } if (test == NULL) print_usage_and_exit(argv[0]); /* Compile shaders */ prog = glCreateProgram(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text); glAttachShader(prog, vs); asprintf(&gs_text, gs_template, test->input_layout, test->vertices_per_prim); gs = piglit_compile_shader_text(GL_GEOMETRY_SHADER, gs_text); free(gs_text); glAttachShader(prog, gs); glTransformFeedbackVaryings(prog, test->vertices_per_prim, varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); /* Set up other GL state */ glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &xfb_buf); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, MAX_OUTPUT_VERTICES * sizeof(GLint), NULL, GL_STREAM_READ); glGenQueries(1, &generated_query); glEnable(GL_RASTERIZER_DISCARD); for (i = 0; i < test->num_test_vectors; i++) { pass = do_test_vector(test, &test->test_vectors[i]) && pass; } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
/** * @brief glBeginTimeQuery * @return */ inline GLuint glBeginTimeQuery() { //Timing GLuint ret; glGenQueries(1, &ret); glFinish(); #ifndef PIC_DISABLE_OPENGL_NON_CORE glBeginQuery(GL_TIME_ELAPSED_EXT, ret); #endif return ret; }
GLTimerQuery::GLTimerQuery() :mQueryStartObj(0), mQueryEndObj(0), mFinalized(false), mEndIssued(false), mTimeDelta(0.0f) { GLuint queries[2]; glGenQueries(2, queries); mQueryStartObj = queries[0]; mQueryEndObj = queries[1]; BS_INC_RENDER_STAT_CAT(ResCreated, RenderStatObject_Query); }
void GL3OcclusionQueryProvider::create() { OpenGL::set_active(gc_provider); if (handle) { glDeleteQueries(1, &handle); handle = 0; } glGenQueries(1, &handle); }
void Profiler::grow(size_t newsize) { size_t oldsize = m_entries.size(); assert(newsize > oldsize); m_entries.resize(newsize); for (size_t i = oldsize; i < newsize; i++){ Entry &entry = m_entries[i]; glGenQueries(2 * FRAME_DELAY, &entry.queries[0]); entry.name = NULL; } }
void MetricBackend_opengl::beginQuery(QueryBoundary boundary) { // GPU related if (glQueriesNeeded[boundary]) { std::array<GLuint, QUERY_LIST_END> query; glGenQueries(QUERY_LIST_END, query.data()); if (metrics[METRIC_GPU_START].profiled[boundary] || (metrics[METRIC_GPU_DURATION].profiled[boundary] && supportsTimestamp)) { glQueryCounter(query[QUERY_GPU_START], GL_TIMESTAMP); } if (metrics[METRIC_GPU_DURATION].profiled[boundary] && !supportsTimestamp) { glBeginQuery(GL_TIME_ELAPSED, query[QUERY_GPU_DURATION]); } if (metrics[METRIC_GPU_PIXELS].profiled[boundary]) { glBeginQuery(GL_SAMPLES_PASSED, query[QUERY_OCCLUSION]); } queries[boundary].push(std::move(query)); } // CPU related if (metrics[METRIC_CPU_START].profiled[boundary] || metrics[METRIC_CPU_DURATION].profiled[boundary]) { cpuStart[boundary] = getCurrentTime(); if (metrics[METRIC_CPU_START].profiled[boundary]) { int64_t time = cpuStart[boundary] * cpuTimeScale - baseTime; data[METRIC_CPU_START][boundary]->addData(boundary, time); } } if (metrics[METRIC_CPU_VSIZE_START].profiled[boundary] || metrics[METRIC_CPU_VSIZE_DURATION].profiled[boundary]) { vsizeStart[boundary] = os::getVsize(); if (metrics[METRIC_CPU_VSIZE_START].profiled[boundary]) { int64_t time = vsizeStart[boundary]; data[METRIC_CPU_VSIZE_START][boundary]->addData(boundary, time); } } if (metrics[METRIC_CPU_RSS_START].profiled[boundary] || metrics[METRIC_CPU_RSS_DURATION].profiled[boundary]) { rssStart[boundary] = os::getRss(); if (metrics[METRIC_CPU_RSS_START].profiled[boundary]) { int64_t time = rssStart[boundary]; data[METRIC_CPU_RSS_START][boundary]->addData(boundary, time); } } queryInProgress[boundary] = true; // DRAWCALL is a CALL if (boundary == QUERY_BOUNDARY_DRAWCALL) beginQuery(QUERY_BOUNDARY_CALL); }
void piglit_init(int argc, char **argv) { GLuint vs; int i; /* Parse params. */ if (argc != 2) print_usage_and_exit(argv[0]); test_to_run = find_matching_test(argv[0], argv[1]); /* Set up test */ piglit_require_GLSL_version(test_to_run->version); piglit_require_transform_feedback(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, test_to_run->vs); prog = glCreateProgram(); glAttachShader(prog, vs); glBindAttribLocation(prog, 0, "vertex_pos"); glBindAttribLocation(prog, 1, "vertex_num"); glTransformFeedbackVaryings(prog, test_to_run->num_varyings, (const char **) test_to_run->varyings, GL_INTERLEAVED_ATTRIBS_EXT); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } /* Test that GetTransformFeedbackVarying reports the correct * size and type for all of the varyings. */ for (i = 0; i < test_to_run->num_varyings; ++i) { GLsizei size; GLenum type; glGetTransformFeedbackVarying(prog, i, 0, NULL, &size, &type, NULL); if (size != test_to_run->expected_size) { printf("For varying %i, expected size %i, got %i\n", i, test_to_run->expected_size, size); size_and_type_ok = GL_FALSE; } if (type != test_to_run->expected_type) { printf("For varying %i, expected type %i, got %i\n", i, test_to_run->expected_type, type); size_and_type_ok = GL_FALSE; } } glGenBuffers(1, &xfb_buf); glGenQueries(1, &query); glEnable(GL_VERTEX_PROGRAM_TWO_SIDE); }
GL3PlusRenderToVertexBuffer::GL3PlusRenderToVertexBuffer() : mTargetBufferIndex(0) , mFirstUpdate(true) { mVertexBuffers[0].setNull(); mVertexBuffers[1].setNull(); // Create query objects. OGRE_CHECK_GL_ERROR(glGenQueries(1, &mPrimitivesDrawnQuery)); //TODO GL4+ // glGenTransformFeedbacks(1, mFeedbackObject); }
/*virtual*/ void GPUTimer::start(){ if(0 == m_id){ glGenQueries(1, &m_id); if(0 == m_id){ std::cerr << "ERROR: GPUTimer::start() ...could not request a query id" << std::endl; exit(0); } } glBeginQuery(GL_TIME_ELAPSED_EXT, m_id); }
void GPUClock::start() { // Stop the time query to restart it. if(mStarted) glEndQuery(GL_TIME_ELAPSED); if(!mQuery) glGenQueries(1, &mQuery); glBeginQuery(GL_TIME_ELAPSED, mQuery); mStarted = true; mStopped = false; }
void GPU_Profile::create_timer() { u32 timer = 0; #ifdef GLSL4_API glGenQueries(1, &timer); glQueryCounter(timer, GL_TIMESTAMP); #endif datas.push_back(ProfileInfo(timer, frame, draw)); #ifdef ENABLE_MARKER dump(true); #endif }
void TerrainTessellation::initRendering(void) { if (!requireExtension("GL_ARB_tessellation_shader")) return; glClearColor(0.0f, 0.0f, 0.0f, 1.0f); NvAssetLoaderAddSearchPath("TerrainTessellation"); loadShaders(); CHECK_GL_ERROR(); // // Create a single default program pipeline to handle binding and unbinding // separate shader objects // glGenProgramPipelines( 1, &mTerrainPipeline); glBindProgramPipeline( mTerrainPipeline); CHECK_GL_ERROR(); //create ubo and initialize it with the structure data glGenBuffers( 1, &mUBO); glBindBuffer( GL_UNIFORM_BUFFER, mUBO); glBufferData( GL_UNIFORM_BUFFER, sizeof(TessellationParams), &mParams, GL_STREAM_DRAW); CHECK_GL_ERROR(); //create simple single-vertex VBO float vtx_data[] = { 0.0f, 0.0f, 0.0f, 1.0f}; glGenBuffers( 1, &mVBO); glBindBuffer( GL_ARRAY_BUFFER, mVBO); glBufferData( GL_ARRAY_BUFFER, sizeof(vtx_data), vtx_data, GL_STATIC_DRAW); CHECK_GL_ERROR(); srand(0); int noiseSize = 256; int noiseSize3D = 64; mRandTex = createNoiseTexture2D(noiseSize, noiseSize, GL_R8); CHECK_GL_ERROR(); mRandTex3D = createNoiseTexture4f3D(noiseSize3D, noiseSize3D, noiseSize3D, GL_RGBA8); CHECK_GL_ERROR(); mParams.invNoiseSize = 1.0f / noiseSize; mParams.invNoise3DSize = 1.0f / noiseSize3D; glGenQueries(1, &mGPUQuery); CHECK_GL_ERROR(); //initTerrainFbo(); //updateQuality(); //CHECK_GL_ERROR(); }
void init(){ glewExperimental = GL_TRUE; GLenum err = glewInit(); if (GLEW_OK != err) { std::cerr << "Error: "<< glewGetErrorString(err) << std::endl; } else { if (GLEW_VERSION_3_3) { std::cout<< "Driver supports OpenGL 3.3\nDetails:"<< std::endl; std::cout << "Using GLEW " << glewGetString(GLEW_VERSION)<< std::endl; std::cout << "Vendor: " << glGetString (GL_VENDOR)<< std::endl; std::cout << "Renderer: " << glGetString (GL_RENDERER)<< std::endl; std::cout << "Version: " << glGetString (GL_VERSION)<< std::endl; std::cout << "GLSL: " << glGetString (GL_SHADING_LANGUAGE_VERSION)<< std::endl; } } glGetError(); fullscreenQuad = new Quad(); simpleShader = new Shader("shaders/passthrough.vert", "shaders/simple.frag"); noiseTexture = new Texture2D(); noiseTexture->loadFromFile(std::string("../common/images/noise.tga")); dataBuffer = new Framebuffer(labyrinthSize, labyrinthSize, 2, true, false); generateShader = new Shader("shaders/passthrough.vert", "shaders/generate.frag"); visualizeTex = new Framebuffer(dataBuffer->getWidth() * 2 + 1, dataBuffer->getHeight() * 2 + 1, 1, false, false); visualizeShader = new Shader("shaders/passthrough.vert", "shaders/visualize.frag"); shortestPath = new Framebuffer(labyrinthSize, labyrinthSize, 1, false, true); glGenBuffers(2,streamoutBufffer); glBindBuffer(GL_ARRAY_BUFFER_ARB,streamoutBufffer[0]); glBufferData(GL_ARRAY_BUFFER_ARB, labyrinthSize*labyrinthSize*4*sizeof(float)*2,0,GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER_ARB,streamoutBufffer[1]); glBufferData(GL_ARRAY_BUFFER_ARB, labyrinthSize*labyrinthSize*4*sizeof(float)*2,0,GL_DYNAMIC_DRAW); searchShader = new Shader("shaders/search.vert", "shaders/search.frag", "shaders/search.geom"); walkPathShader = new Shader("shaders/search.vert", "shaders/red.frag", "shaders/walkpath.geom"); glGenQueries(1, &outputQuery); glutReshapeWindow(labyrinthSize * windowScale, labyrinthSize * windowScale); }
void piglit_init(int argc, char **argv) { if (argc != 2) print_usage_and_exit(argv[0]); if (strcmp(argv[1], "discard") == 0) discard = GL_TRUE; else if (strcmp(argv[1], "buffer") == 0) buffer = GL_TRUE; else if (strcmp(argv[1], "prims_written") == 0) prims_written = GL_TRUE; else if (strcmp(argv[1], "prims_generated") == 0) prims_generated = GL_TRUE; else print_usage_and_exit(argv[0]); piglit_require_transform_feedback(); if (buffer || prims_written) { GLuint vs; piglit_require_GLSL(); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); xfb_prog = glCreateProgram(); glAttachShader(xfb_prog, vs); glTransformFeedbackVaryings(xfb_prog, 1, xfb_varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(xfb_prog); if (!piglit_link_check_status(xfb_prog)) { piglit_report_result(PIGLIT_FAIL); } glGenBuffers(1, &xfb_buf); } if (prims_written) { glGenQueries(1, &prims_written_query); } if (prims_generated) { glGenQueries(1, &prims_generated_query); } }
ScopedGPUTimer::ScopedGPUTimer(GPUTimer &t) : timer(t) { if (!UserConfigParams::m_profiler_enabled) return; if (profiler.isFrozen()) return; if (!timer.canSubmitQuery) return; #ifdef GL_TIME_ELAPSED if (!timer.initialised) { glGenQueries(1, &timer.query); timer.initialised = true; } glBeginQuery(GL_TIME_ELAPSED, timer.query); #endif }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { bool pass = true; float green[4] = {0.0, 1.0, 0.0, 0.0}; GLuint q; GLuint list; list = glGenLists(1); glNewList(list, GL_COMPILE); glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glGenQueries(1, &q); /* Generate query pass: draw bottom half of screen. */ glColor4f(0.0, 1.0, 0.0, 0.0); glBeginQuery(GL_SAMPLES_PASSED, q); piglit_draw_rect(-1, -1, 2, 1); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should draw top half of screen. */ glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); piglit_draw_rect(-1, 0, 2, 1); glEndConditionalRenderNV(); /* Generate query fail */ glBeginQuery(GL_SAMPLES_PASSED, q); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should not draw full screen. */ glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); glColor4f(1.0, 0.0, 0.0, 0.0); piglit_draw_rect(-1, -1, 2, 2); glEndConditionalRenderNV(); glEndList(); glCallList(list); pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green); piglit_present_results(); glDeleteQueries(1, &q); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void GpuTimer::start() { QueryPair qp; if (availablePairs.empty()) { glGenQueries(1, &qp.startQuery); glGenQueries(1, &qp.endQuery); } else { qp = availablePairs.front(); availablePairs.pop(); // Reuse old OpenGL ids, no need for additional glGenQueries. } inflightPairs.push(qp); // Create a fence and insert it into the command stream. This fence will be signaled // when the GPU has completed all previously issued commands. glWaitSync will defer // subsequently issued commands (without blocking CPU) until the fence signals. // This prevents overlapped execution of OpenGL calls and should make timing measurements // more precise. For more, see e.g. OpenGL Insights. GLsync sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); glWaitSync(sync, 0, GL_TIMEOUT_IGNORED); glDeleteSync(sync); // Flag for deletion. glQueryCounter(qp.startQuery, GL_TIMESTAMP); }
static void init_if_needed() { static int is_initialized = 0; if (is_initialized) return; glGenQueries(num_timer_queries, timer_queries); for (int i = 0; i < num_timer_queries; ++i) { query_names[i] = NULL; } checkpoint_times = map__new(str_hash, str_eq); checkpoint_callbacks = map__new(str_hash, str_eq); is_initialized = 1; }
void VertexBuffer::DrawToFeedbackBuffer(VertexBuffer* target, ShaderProgram* shader_program, bool keep_fragments) { GLDEBUG(); if(!keep_fragments) glEnable(GL_RASTERIZER_DISCARD); ShaderProgram::SetActiveProgram(shader_program); GLchar const* strings[] = { "gl_Position" }; // glTransformFeedbackVaryings(shader_program->program_id, 1, strings, GL_SEPARATE_ATTRIBS); // we must re-link the program to force some things to update (i think?) glLinkProgram(shader_program->program_id); GLuint query; glGenQueries(1, &query); GLuint out_buf; glGenBuffers(1, &out_buf); glBindBuffer(GL_ARRAY_BUFFER, out_buf); glBufferData(GL_ARRAY_BUFFER, 4 * num_verts * sizeof(float), NULL, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, out_buf); // glBindVertexArray(transform vertex array name); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query); glBeginTransformFeedback((GLenum)storage_mode); glDrawArrays((GLenum)storage_mode, 0, num_verts); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glDisable(GL_RASTERIZER_DISCARD); GLuint primitives_written = 0; glGetQueryObjectuiv(query, GL_QUERY_RESULT, &primitives_written); glDeleteQueries(1, &query); /* TODO: put results into target */ GLDEBUG(); }
void initGPUTimer (GPUtimer * timer) { memset (timer, 0, sizeof (*timer)); /* timer->supported = glfwExtensionSupported("GL_ARB_timer_query"); if (timer->supported) {*/ //#ifndef GL_ARB_timer_query //glGetQueryObjectui64v = (pfnGLGETQUERYOBJECTUI64V)glfwGetProcAddress("glGetQueryObjectui64v"); ////printf("glGetQueryObjectui64v=%p\n", glGetQueryObjectui64v); //if (!glGetQueryObjectui64v) { //timer->supported = GL_FALSE; //return; //}*/ //#endif glGenQueries (GPU_QUERY_COUNT, timer->queries); //} }
OpenGLRenderer::OpenGLRenderer() { // We need to query for some profiling exts. ogl_CheckExtensions(); glGenQueries(1, &debugQuery); createUBO(UBOScene, sizeof(SceneUniformData), sizeof(SceneUniformData)); glBindBufferBase(GL_UNIFORM_BUFFER, kUBOIndexScene, UBOScene.name); GLint MaxUBOSize; glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &MaxUBOSize); createUBO(UBOObject, MaxUBOSize, sizeof(ObjectUniformData)); swap(); }
GpuQuery::GpuQuery() : m_id(0) { Context::EnsureContext(); m_id = 0; glGenQueries(1, static_cast<GLuint*>(&m_id)); #ifdef NAZARA_DEBUG if (!m_id) { NazaraError("Failed to create occlusion query"); throw std::runtime_error("Constructor failed"); } #endif }
void initGPUTimer(struct GPUtimer* timer) { memset(timer, 0, sizeof(*timer)); timer->supported = glfwExtensionSupported("GL_ARB_timer_query"); if (timer->supported) { #ifndef GL_ARB_timer_query glGetQueryObjectui64v = (pfnGLGETQUERYOBJECTUI64V)glfwGetProcAddress("glGetQueryObjectui64v"); if (!glGetQueryObjectui64v) { timer->supported = GL_FALSE; return; } #endif glGenQueries(GPU_QUERY_COUNT, timer->queries); } }