Compute shaders support?

[evdem]

Experimental WebGL2 Compute shaders are supported in Chrome Canary. See e.g. my pages https://www.ibiblio.org/e-notes/webgl/gpu/contents.htm. Is it possible to add WebGL2-compute into gpu.js? Couldn't you help (guide) me how to add them? (I get refuse from WebDNN :)

By the way are HALF_FLOAT data supported in gpu.js? Simple test at https://www.ibiblio.org/e-notes/webgl/gpu/tex2_16.htm

Evgeny Demidov

[robertleeplummerjr]

Can you show a scenario where it'd be helpful? I'm sure we could support it.

[evdem]

as for HALF_FLOAT, then f16 gives x2 acceleration (for free and very useful for AI, ML they say) on modern GPU Intel (SkyLake is tested in OpenCL), mobile, Nvidia (Turing in Cuda). Both throughput (mediump precision) and bandwidth (HALF_FLOAT).

as for compute shaders see https://www.ibiblio.org/e-notes/webgl/gpu/mul/sgemm.htm. Cedric Nugteren (in OpenCL very similar to compute shaders) get x5 acceleration for script with shared memory wit respect to naive one. I get only 50% in experimental WebGL2-compute yet. I can compare WebGL and WebDL2-compute (in a while).

[jacobbogers]

they are not called compute shaders its a render extention (so not part of standard) to the webgl2, but its only lives in the fragment shader, I see from the gpu.js most of the heavy duty stuff is done in the vertex shader, i dont know all of the code so maybe the latter is not true anymore. for ML training I would still use 32 bit floating point, once your model has been trained, you can execute the model with 16 bit floats, thats how it is done.

[robertleeplummerjr]

I think vertex shaders are pretty light actually:

• WebGL1 vertex shader: https://github.com/gpujs/gpu.js/blob/develop/src/backend/web-gl/vertex-shader.js
• WebGL2 vertex shader: https://github.com/gpujs/gpu.js/blob/develop/src/backend/web-gl2/vertex-shader.js

However, the bulk of code is in fragment shaders:

• WebGL1 fragment shader: https://github.com/gpujs/gpu.js/blob/develop/src/backend/web-gl/fragment-shader.js
• WebGL2 fragment shader: https://github.com/gpujs/gpu.js/blob/develop/src/backend/web-gl2/fragment-shader.js

NOTE: for fragment shaders, much of the source is injected from the kernel class. Example for WebGL2: https://github.com/gpujs/gpu.js/blob/develop/src/backend/web-gl/kernel.js

I still don't see an issue with support, even if it is only webgl2. The thing we have to think about is what the API looks like from a javascript viewpoint. Like what connects where, and proposed features etc.

[jacobbogers]

great, Thanks for clarifying about the fragment shaders,

[evdem]

I've added WebGL2 based GEMM test (with R32F textures) at https://www.ibiblio.org/e-notes/webgl/gpu/mul/sgemm.htm . Where can I find gpu.js based test? ;) Sorry, I've to check today my test results for GT 710 (WG threads synchronization is corrected). I'm working on compute shader optimization for GEMM.

[evdem]

1. WebGL2 is based on OpenGL ES 3.0, WebGL2-compute on ES 3.1
2. HALF_FLOAT and int8 math are very important for ML (remember tensor cores). It saves bandwidth (at least, right now) and throughput (if FP16 math is supported by HW and drivers) .
3. my test results are still not clear (hope optimized compute shaders will be x2 faster).
4. all that is not very urgent now (for near future)
5. does gpu.js support FFT or image convolution (filtering by a small NxN kernel matrix (FLOAT, HALF_FLOAT of may be int8 :) for ML)?

[robertleeplummerjr]

Where are the sources for your tests? We just have to plan and make it practical for JavaScript, and them implementation will follow. If I can see your sources it can help me and others to see how it can be enabled and utilized.

[robertleeplummerjr]

This is it? https://www.ibiblio.org/e-notes/webgl/gpu/mul/sgemm3.htm

[evdem]

yes, it is the fastest third shader (you can see JS in the page source). Now I'm working on the 4 shader. The first one is the simplest. https://www.ibiblio.org/e-notes/webgl/gpu/mul/mul32b.htm - my WebGL2 test with R32F textures.

[robertleeplummerjr]

Very cool. It looks as though this is the main means of interaction then, that'd need to be integrated?:

for(int i=0; i<n; i++)
    acc += texelFetch(samp0, ivec2(gl_FragCoord.x, i), 0).r * 
           texelFetch(samp1, ivec2(i, gl_FragCoord.y), 0).r;

In other words, texelFetch?

[robertleeplummerjr]

Short of other configurations, for example, to gl.something, adding that into the member expressions function node (the thing that transpiles), even if it is custom for webgl2 (or webgl2-compute?) will be easy. Here is where it is currently implemented:

gpu.js/src/backend/web-gl/function-node.js

Line 752 in adf5062

switch (type) {

The javascript means of fallback would seem to be a simple array[z][y][x]

[evdem]

texelFetch(samp0, ivec2(gl_FragCoord.x, i), 0).r is analog of texture2D(samp, vTexCoord).r Look at OpenGL ES spec or Google. The mul32 script is just matrix multiplication.

[jacobbogers]

Hi evdem,
sgemm is one of the most straightforward of blas kernels (level3) to port,
I am doing the same thing for all my level 3 BLAS kernels porting them to webgl2
Level 3 routines,
https://github.com/R-js/blasjs#level-3-routines
For FFT, i am not sure if that is usefull unless for sound, for jpeg compression/decompression, maybe, but the Canvas object can handle that already

[evdem]

I'm from webgl-dev-list :) At first I'd like to get a good test-case for compute shaders. It is interesting if they will be faster than WebGL2 with textures. It is not clear as texture uses its one memory HW.