V8 memory leak?

[guest271314]

When I pass input array to a Deno Native Messaging host having length 4096*4 which when stringified as JSON has length 81921 Deno Native Messaging host memory usage grows to 1GB then the script exits. The same thing happens with Node.js Native Messaging host. Both are dependent on V8 JavaScript engine.

Not so long ago I was able to pass new Array(200000) to each Native Messaging host and get echoed stdout.

QuickJS, C, and C++ Native Messaging hosts can each process 200000 array input. Python exists when input is 175000.

Is there a recent change to V8 which limits input to stadin and/or stdout; caches or buffers stdin or stdout?

[guest271314]

@bartlomieju @ayame113 @lucacasonato @crowlKats @ry

I'm pretty sure this is a bug in V8.

Unless one of you can explain why V8 is writing 1567386741 to the uint32 when the actual length of the input is 65536?

When input to stdin is equal to or greater than 65536 memory usage exponentially increases to upwards of 700MB-1GB - this happens only when using Node.js or Deno JavaScript engines .

Using the same code with QuickJS JavaScript engine, C and C++ Native Messaging hosts I get no such unexpected behaviour.

I narrowed down the range when this happens and write what happens to a file.

port.postMessage(new Array((4096*3)+818));

65531

is written to log.txt, which is expected

JSON.stringify(new Array((4096*3)+818)).length // 65531

when I add 1 to that input array

port.postMessage(new Array((4096*3)+819));

1567386741

is written to log.txt.

The relevant Deno code

async function getMessage() {
  const header = new Uint32Array(1);
  await Deno.stdin.read(header);
  await Deno.writeTextFile("log.txt", header[0]);
  const output = new Uint8Array(header[0]);
  await Deno.stdin.read(output);
  return output;
}

Node.js code

function getMessage() {
   const header = new Uint32Array(1);
  readSync(0, header);
  const content = new Uint8Array(header[0]);
  writeFileSync('log.txt', JSON.stringify(header[0]));
  readSync(0, content);
  return content;
}

[0f-0b]

It fails when receiving the second message because Deno.stdin.read(buffer) is not guaranteed to read exactly buffer.byteLength bytes, and thus the first message was not fully read. BufReader from std provides a convenient way to ensure that the whole buffer is filled.

import { BufReader } from "https://deno.land/std@0.170.0/io/buf_reader.ts";
import { BufWriter } from "https://deno.land/std@0.170.0/io/buf_writer.ts";

const stdin = new BufReader(Deno.stdin);
const stdout = new BufWriter(Deno.stdout);

async function getMessage() {
  const header = new Uint32Array(1);
  await stdin.readFull(new Uint8Array(header.buffer));
  const message = new Uint8Array(header[0]);
  await stdin.readFull(message);
  return message;
}

async function sendMessage(message) {
  const header = new Uint32Array([message.length]);
  await stdout.write(new Uint8Array(header.buffer));
  await stdout.write(message);
  await stdout.flush();
}

I am not aware of any built-in equivalent in Node, but the following should work.

function readFullSync(fd, buf) {
  let offset = 0;
  while (offset < buf.byteLength) {
    offset += readSync(fd, buf, { offset });
  }
  return buf;
}

function getMessage() {
  const header = new Uint32Array(1);
  readFullSync(0, header);
  const content = new Uint8Array(header[0]);
  readFullSync(0, content);
  return content;
}

Original answer

I cannot reproduce this locally.

I installed the native messaging example and modified it as follows. When I visit main.html, 65536 is written to log.txt as expected.

// app/main.js
const port = chrome.runtime.connectNative("com.google.chrome.example.echo");
port.postMessage(new Array((4096 * 3) + 819));

// host/native-messaging-example-host
#!/usr/bin/env -S deno run --allow-write=log.txt

async function getMessage() {
  const header = new Uint32Array(1);
  await Deno.stdin.read(header);
  await Deno.writeTextFile("log.txt", header[0]);
  const output = new Uint8Array(header[0]);
  await Deno.stdin.read(output);
  return output;
}

await getMessage();

[guest271314]

I see. It fails when receiving the second message. This is because Deno.stdin.read(buffer) is not guaranteed to read exactly buffer.byteLength bytes, and thus the first message was not fully read. BufReader from std provides a convenient way to ensure that the whole buffer is filled.

Ahh. That changes everything. Thanks. Now able to write and read new Array(200000).

What is the equivalent in the Node.js version?

In pertinent part

#!/usr/bin/env -S ./node --max-old-space-size=6 --jitless --expose-gc --v8-pool-size=1
// Node.js Native Messaging host
// guest271314, 10-9-2022
import {readSync} from 'node:fs';
// Node.js Native Messaging host constantly increases RSS during usage
// https://github.com/nodejs/node/issues/43654
process.env.UV_THREADPOOL_SIZE = 1;
// Process greater than 65535 length input
// https://github.com/nodejs/node/issues/6456
// https://github.com/nodejs/node/issues/11568#issuecomment-282765300
process.stdout._handle.setBlocking(true);

function getMessage() {
  const header = new Uint32Array(1);
  readSync(0, header);
  const content = new Uint8Array(header[0]);
  readSync(0, content);
  return content;
}

[guest271314]

@0f-0b How do I mark your answer as answered?

[0f-0b]

What is the equivalent in the Node.js version?

I am too unfamiliar with Node to know if there is a built-in equivalent, but the following might work.

function readFullSync(fd, buf) {
  let offset = 0;
  while (offset < buf.byteLength) {
    offset += readSync(fd, buf, { offset });
  }
  return buf;
}

function getMessage() {
  const header = new Uint32Array(1);
  readFullSync(0, header);
  const content = new Uint8Array(header[0]);
  readFullSync(0, content);
  return content;
}

How do I mark your answer as answered?

I edited my answer to reflect the actual solution. Or perhaps you could post your finished code in a new answer and mark that as answered?

[guest271314]

That does work. Thanks again.

[guest271314]

Can you kindly also include that code in your accepted answer as well re my subsequent Node.js equivalent question?