What is the correct way to ensure zero copy of an ArrayBuffer and the ability to transfer back to the main thread (without reassignment)

[CMCDragonkai]

I have a worker function:

  mutate (what: ArrayBuffer): TransferDescriptor<ArrayBuffer> {
    const inView = new Uint8Array(what);
    inView[0] = 88;
    return Transfer(what);
  },

When I Transfer an ArrayBuffer into this method, the original ArrayBuffer becomes detached.

  const what = await workerManager.call(
    async w => {
      const o = await w.mutate(Transfer(ab));
      return o;
    }
  );

ab => ArrayBuffer { (detached), byteLength: 0 }
what => ArrayBuffer { [Uint8Contents]: <58 62 63>, byteLength: 3 }

Note that the call method just does this:

  public async call<T>(
    f: (worker: ModuleThread<EFSWorker>) => Promise<T>,
  ): Promise<T> {
    if (!this.pool) {
      throw new workersErrors.EncryptedFSWorkerNotRunningError();
    }
    return await this.pool.queue(f);
  }

I notice I have to use the returned array buffer. The ab is no longer usable.

I thought I would be able to share a buffer with a thread, make that thread make mutations, and then share that buffer back, but the above seems to mean that I have to use a new assignment, and discard the old assignment.

Furthermore I actually want to use Node buffers. But when I use node buffers with the internal array buffer, the internal array buffer gets detached even under the same usage. This is quite strange behaviour.

This is a follow up from #348

[andywer]

Please check out my answer in #348. I think it covers that topic as well.

I wonder if there should be a package with serializers for commonly used data types like Buffers. We cannot really add it to threads.js itself, though, as that will not work in browsers.