Order-dependent transpilation of this.thread.x * scale

[markebowles]

What is wrong?

Multiplying this.thread.x (and y) by a float scale functions differently depending on the operand order. GPU interprets the scale as an integer in the form "this.thread.x scale", but in the form "scale this.thread.x" the scale is interpreted as a float.

Where does it happen?

Latest version of gpu.js in gpu mode, mac os x, chrome browser.

How do we replicate the issue?

        const gpu = new GPU({ mode: "gpu" });
        const canvas1 = document.getElementById("canvas1");
        const ctx1 = canvas1.getContext("webgl2", { alpha: true, premultipliedAlpha: false });

        test1 = gpu.createKernel(
            function (scale) {
                // in this expression, scale is treated as an integer
                return (this.thread.x * scale);
            })
            .setOutput([10])
            .setCanvas(canvas1)
            .setContext(ctx1);

        test2 = gpu.createKernel(
            function (scale) {
                // in this order, scale is treated as a float.
                return (scale * this.thread.x);
            })
            .setOutput([10])
            .setCanvas(canvas1)
            .setContext(ctx1);

        result = test1(1.77);
        console.log(`test1 result: ${result}`);  // 0,1,2,3,4,5,6,7,8,9

        result = test2(1.77);
        console.log(`test2 result: ${result}`);  // 0,1.7699999809265137,3.5399999618530273, ...

How important is this (1-5)?

There's an easy work-around, but it might help to include the workaround in the documentation.

Expected behavior (i.e. solution)

Javascripters are trained (aka brainwashed) to believe that "everything is a number, there's no such thing as an int". This is why it took me a day to find this problem -- the expectation is that regardless of the ordering of the expression, any scalar input to a kernel should be interpreted as a float.

Would this behavior also manifest with other sources of ints in the kernel, e.g. when we extract a cell from a Uint8Array argument?

Is this a bug that should ultimately be fixed, or a necessary side-effect of the transpilation process?

Other Comments

GPU.js is an extraordinarily useful and clever mechanism for producing high-performance code in desktop and mobile applications! Fantastic work!

[markebowles]

Update: replace the argument "scale" with a constant, e.g.:

test1 = gpu.createKernel(
            function () {
                // in this expression, the constant 1.77 is treated as an integer
                return (this.thread.x * 1.77);
            })
            .setOutput([10])
            .setCanvas(canvas1)
            .setContext(ctx1);

This also produces the unexpected integer behavior.