Dereference array args instead of creating copies.

diff --git a/src/lib/workers/powgpu.ts b/src/lib/workers/powgpu.ts
index 6aff313245e391256712118f288387f24cb95b4b..4616d69562ded523e6e67f310a36eef33479d769 100644 (file)
--- a/src/lib/workers/powgpu.ts
+++ b/src/lib/workers/powgpu.ts
@@ -85,55 +85,53 @@ export class PowGpu extends WorkerInterface {
                * Sets v[a,a+1] += b
                * b0 is the low 32 bits of b, b1 represents the high 32 bits
                */
-               fn add_uint64 (ptr_v: ptr<function, array<u32, 32>>, a: u32, b0: u32, b1: u32) {
-                       var o0: u32 = (*ptr_v)[a] + b0;
-                       var o1: u32 = (*ptr_v)[a+1u] + b1;
-                       if ((*ptr_v)[a] > 0xFFFFFFFFu - b0) { // did low 32 bits overflow?
+               fn add_uint64 (v: ptr<function, array<u32, 32>>, a: u32, b0: u32, b1: u32) {
+                       var o0: u32 = (*v)[a] + b0;
+                       var o1: u32 = (*v)[a+1u] + b1;
+                       if ((*v)[a] > 0xFFFFFFFFu - b0) { // did low 32 bits overflow?
                                o1 = o1 + 1u;
                        }
-                       (*ptr_v)[a] = o0;
-                       (*ptr_v)[a+1u] = o1;
+                       (*v)[a] = o0;
+                       (*v)[a+1u] = o1;
                }
 
                /**
                * G Mixing function
                */
-               fn B2B_G (ptr_v: ptr<function, array<u32, 32>>, ptr_m: ptr<function, array<u32, 16>>, a: u32, b: u32, c: u32, d: u32, ix: u32, iy: u32) {
-                       var v: array<u32, 32> = (*ptr_v);
-                       var m: array<u32, 16> = (*ptr_m);
-                       add_uint64(ptr_v, a, v[b], v[b+1u]);
-                       add_uint64(ptr_v, a, m[ix], m[ix+1u]);
+               fn B2B_G (v: ptr<function, array<u32, 32>>, m: ptr<function, array<u32, 16>>, a: u32, b: u32, c: u32, d: u32, ix: u32, iy: u32) {
+                       add_uint64(v, a, (*v)[b], (*v)[b+1u]);
+                       add_uint64(v, a, (*m)[ix], (*m)[ix+1u]);
 
                        // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
-                       var xor0: u32 = v[d] ^ v[a];
-                       var xor1: u32 = v[d+1u] ^ v[a+1u];
-                       v[d] = xor1;
-                       v[d+1u] = xor0;
+                       var xor0: u32 = (*v)[d] ^ (*v)[a];
+                       var xor1: u32 = (*v)[d+1u] ^ (*v)[a+1u];
+                       (*v)[d] = xor1;
+                       (*v)[d+1u] = xor0;
 
-                       add_uint64(ptr_v, c, v[d], v[d+1u]);
+                       add_uint64(v, c, (*v)[d], (*v)[d+1u]);
 
                        // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
-                       xor0 = v[b] ^ v[c];
-                       xor1 = v[b+1u] ^ v[c+1u];
-                       v[b] = (xor0 >> 24u) ^ (xor1 << 8u);
-                       v[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
+                       xor0 = (*v)[b] ^ (*v)[c];
+                       xor1 = (*v)[b+1u] ^ (*v)[c+1u];
+                       (*v)[b] = (xor0 >> 24u) ^ (xor1 << 8u);
+                       (*v)[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
 
-                       add_uint64(ptr_v, a, v[b], v[b+1u]);
-                       add_uint64(ptr_v, a, m[iy], m[iy+1u]);
+                       add_uint64(v, a, (*v)[b], (*v)[b+1u]);
+                       add_uint64(v, a, (*m)[iy], (*m)[iy+1u]);
 
                        // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
-                       xor0 = v[d] ^ v[a];
-                       xor1 = v[d+1u] ^ v[a+1u];
-                       v[d] = (xor0 >> 16u) ^ (xor1 << 16u);
-                       v[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
+                       xor0 = (*v)[d] ^ (*v)[a];
+                       xor1 = (*v)[d+1u] ^ (*v)[a+1u];
+                       (*v)[d] = (xor0 >> 16u) ^ (xor1 << 16u);
+                       (*v)[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
 
-                       add_uint64(ptr_v, c, v[d], v[d+1u]);
+                       add_uint64(v, c, (*v)[d], (*v)[d+1u]);
 
                        // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
-                       xor0 = v[b] ^ v[c];
-                       xor1 = v[b+1u] ^ v[c+1u];
-                       v[b] = (xor1 >> 31u) ^ (xor0 << 1u);
-                       v[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
+                       xor0 = (*v)[b] ^ (*v)[c];
+                       xor1 = (*v)[b+1u] ^ (*v)[c+1u];
+                       (*v)[b] = (xor1 >> 31u) ^ (xor0 << 1u);
+                       (*v)[b+1u] = (xor0 >> 31u) ^ (xor1 << 1u);
                }
 
                /**