Is it possible to measure rendering time in webgl using gl.finish()?

Question

I am trying to measure the time it takes for an image in webgl to load.

I was thinking about using gl.finish() to get a timestamp before and after the image has loaded and subtracting the two to get an accurate measurement, however I couldn't find a good example for this kind of usage.

Is this sort of thing possible, and if so can someone provide a sample code?

Answer 1

It is now possible to time WebGL2 executions with the EXT_disjoint_timer_query_webgl2 extension.

const ext = gl.getExtension('EXT_disjoint_timer_query_webgl2');
const query = gl.createQuery();
gl.beginQuery(ext.TIME_ELAPSED_EXT, query);
/* gl.draw*, etc */
gl.endQuery(ext.TIME_ELAPSED_EXT);

Then sometime later, you can get the elapsed time for your query:

const available = this.gl.getQueryParameter(query, this.gl.QUERY_RESULT_AVAILABLE);
if (available) {
    const elapsedNanos = gl.getQueryParameter(query, gl.QUERY_RESULT);
}

A couple things to be aware of:

• only one timing query may be in progress at once.
• results may become available asynchronously. If you have more than one call to time per frame, you may consider using a query pool.

Answer 2

No it is not.

In fact in Chrome gl.finish is just a gl.flush. See the code and search for "::finish".

Because Chrome is multi-process and actually implements security in depth the actual GL calls are issued in another process from your JavaScript so even if Chrome did call gl.finish it would happen in another process and from the POV of JavaScript would not be accurate for timing in any way shape or form. Firefox is apparently in the process of doing something similar for similar reasons.

Even outside of Chrome, every driver handles gl.finish differently. Using gl.finish for timing is not useful information because it's not representative of actual speed since it includes stalling the GPU pipeline. In other words, timing with gl.finish includes lots of overhead that wouldn't happen in real use and so is not an accurate measurement of how fast something would execute normal circumstances.

There are GL extensions on some GPUs to get timing info. Unfortunately they (a) are not available in WebGL and (b) will not likely ever be as they are not portable as they can't really work on tiled GPUs like those found in many mobile phones.

Instead of asking how to time GL calls what specifically are you trying to achieve by timing them? Maybe people can suggest a solution to that.