[DRAFT] Representing JS semantics in WGSL

[iwoplaza]

Note

This is a draft discussion, expect updates on it

We have 2 goals with TGSL:

• Being able to represent WGSL-specific constructs in JS.
• JS running as you would expect, both on the CPU and CPU.

There are a couple of hurdles we need to overcome:

• WGSL has explicit control over if a parameter gets copied or passed by reference (ptr<>), while in JS, passing primitives always copies, and passing non-primitives does so by reference.
• Assignments copy by default in WGSL
• Numbers have types more precise than just number (i32, u32, f32), yet we cannot overload operators in JS

Value/Reference semantics

Passing primitives by value & passing non-primitives by reference

Not much to do here, primitives are always copied in JS and non-primitives are passed by reference, so we can just fall-through to default JS behavior

Passing primitives by reference

Let's ponder about the following WGSL code

fn increment(value: ptr<function, f32>) {
  (*value) += 1;
}

fn main() -> f32{
  var count = 0;
  increment(&count);
  return count;
}

main() would return 1, since increment is able to act directly on count

How could the equivalent JS code look like? For increment to have direct access to count, the value needs to be non-primitive. To achieve that, we can let developers create boxed values (essentially wrap them in an object with one property). This is only necessary for primitive values, as non-primitives are passed by reference automatically.

const increment = tgpu.fn([d.ptrFn(d.f32)])((val) => {
  // `val` is of type `d.boxed<number>`, `val.$` is of type `number`
  val.$ += 1;
});

const main = tgpu.fn([], d.f32)(() => {
  const count = d.box(0); // => d.boxed<number>
  increment(count);
  return count.$;
});

Passing non-primitives by value

We can just copy the passed arguments when a function is called, which is what we already do