Parsing JSON at 1 MiB lengths

[guest271314]

I'm working on supporting 64 MiB input to a QuickJS NG Native Messaging host. For comparison, here's the working Node.js and AssemblyScript versions

• https://github.com/guest271314/NativeMessagingHosts/blob/main/nm_nodejs.js
• https://github.com/guest271314/NativeMessagingHosts/blob/main/nm_assemblyscript.ts

I think this should work, however, the program is exiting. The pertinent logic is in the statement of if (message.length > 1024 ** 2) {//...}. What's going on here?

function getMessage() {
  const header = new Uint32Array(1);
  std.in.read(header.buffer, 0, 4);
  const output = new Uint8Array(header[0]);
  std.in.read(output.buffer, 0, output.length);
  return output;
}

function encodeMessage(message) {
  return new Uint8Array(
    [...JSON.stringify(message)].map((s) => s.codePointAt()),
  );
}

function sendMessage(message) {
  if (message.length > 1024 ** 2) {
    const json = JSON.parse(String.fromCharCode(...message));
    for (let i = 0; i < json.length; i += 65536) {
      const m = encodeMessage(json.slice(i, i + 65536));
      const header = Uint32Array.from(
        {
          length: 4,
        },
        (_, index) => (m.length >> (index * 8)) & 0xff,
      );
      const output = new Uint8Array(header.length + m.length);
      output.set(header, 0);
      output.set(m, 4);
      std.out.write(output.buffer, 0, output.length);
      std.out.flush();
    }
  } else {
    const header = Uint32Array.from({
      length: 4,
    }, (_, index) => (message.length >> (index * 8)) & 0xff);
    const output = new Uint8Array(header.length + message.length);
    output.set(header, 0);
    output.set(message, 4);
    std.out.write(output.buffer, 0, output.length);
    std.out.flush();
  }
}

[guest271314]

This

const json = JSON.parse(String.fromCharCode(...message));

results in

Uncaught RangeError: Maximum call stack size exceeded

For now substituting this

const json = JSON.parse([...message].map((s) => String.fromCodePoint(s)).join(""));

until I figure out a more performant pattern.

[guest271314]

Using the above freezes the machine when sending 32 MiB from browser to host, then after a few minutes qjs and the browser exits.

I suspect it's the line

const json = JSON.parse([...message].map((s) => String.fromCodePoint(s)).join(""));

How would I go about optimizing that JSON processing?

[bnoordhuis]

Can you isolate the slow part? Is the splat, the map, the string join, JSON.parse?

[guest271314]

Not sure how to do that. I suspect all in conjunction. There's, what, 4 operations happening there? I looked at --trace. Does that have the option to write to a file?

Sucks when the browser and machine freezes.

I wound up doing this https://github.com/guest271314/native-messaging-quickjs/blob/main/nm_qjs.js#L20-L79, which works.

Interestingly, I do this using javy https://github.com/guest271314/native-messaging-webassembly/blob/main/nm_javy.js#L26-L39, which under the hood uses QuickJS. A little bit different, because we have TextDecoder, though still uses the recursive JSON.parse()

  const json = JSON.parse(decoder.decode(data));
  if (Array.isArray(json) && json.length) {
    for (let i = 0; i < json.length; i += maxMessageLengthFromHost) {
      const message = encoder.encode(
        JSON.stringify(json.slice(i, i + maxMessageLengthFromHost)),
      );
      let header = Uint32Array.from({
        length: 4,
      }, (_, index) => (message.length >> (index * 8)) & 0xff);
      let output = new Uint8Array(header.length + message.length);
      output.set(header, 0);
      output.set(message, 4);
      Javy.IO.writeSync(stdout, output);
    }

[guest271314]

I guess this is the "answer". Tested. Works. Doesn't address qjs (NG) memory increasing to 99% when using this const json = JSON.parse([...message].map((s) => String.fromCodePoint(s)).join(""));

function sendMessage(message) {
  if (message.length > 1024 ** 2) {
    const json = message;
    const data = new Array();
    let fromIndex = 1024 ** 2 - 8;
    let index = 0;
    let i = 0;
    do {
      i = json.indexOf(44, fromIndex);
      const arr = json.subarray(index, i);
      data.push(arr);
      index = i;
      fromIndex += 1024 ** 2 - 8;
    } while (fromIndex < json.length);
    if (index < json.length) {
      data.push(json.subarray(index));
    }
    for (let j = 0; j < data.length; j++) {
      const start = data[j][0];
      const end = data[j][data[j].length - 1];
      if (start === 91 && end !== 44 && end !== 93) {
        const x = new Uint8Array(data[j].length + 1);
        for (let i2 = 0; i2 < data[j].length; i2++) {
          x[i2] = data[j][i2];
        }
        x[x.length - 1] = 93;
        data[j] = x;
      }
      if (start === 44 && end !== 93) {
        const x = new Uint8Array(data[j].length + 1);
        x[0] = 91;
        for (let i2 = 1; i2 < data[j].length; i2++) {
          x[i2] = data[j][i2];
        }
        x[x.length - 1] = 93;
        data[j] = x;
      }
      if (start === 44 && end === 93) {
        const x = new Uint8Array(data[j].length);
        x[0] = 91;
        for (let i2 = 1; i2 < data[j].length; i2++) {
          x[i2] = data[j][i2];
        }
        data[j] = x;
      }
    }
    for (let k = 0; k < data.length; k++) {
      const arr = data[k];
      const header = Uint32Array.from(
        {
          length: 4,
        },
        (_, index) => (arr.length >> (index * 8)) & 0xff,
      );
      const output = new Uint8Array(header.length + arr.length);
      output.set(header, 0);
      output.set(arr, 4);
      std.out.write(output.buffer, 0, output.length);
      std.out.flush();
      std.gc();
    }
  } else {
    const header = Uint32Array.from({
      length: 4,
    }, (_, index) => (message.length >> (index * 8)) & 0xff);
    const output = new Uint8Array(header.length + message.length);
    output.set(header, 0);
    output.set(message, 4);
    std.out.write(output.buffer, 0, output.length);
    std.out.flush();
    std.gc();
  }
}

[guest271314]

@bnoordhuis Check this out https://gist.github.com/guest271314/c88d281572aadb2cc6265e3e9eb09810. I'm kinda not on the "AI" boat. I was on Discord posting about the nonsense Gemini was spitting out. A Discord user was feeding Gemini the code I wrote, and the conversation we were having. I did the test of what Gemini spit out based on my initial code and what Gemini spit out, shorter time being faster:

Shorter time being faster.

Testing code, run from the browser in DevTools Snippets

var runtimes = new Map([/*
  ["nm_assemblyscript",0],
  ["nm_bash",0],
  ["nm_bun",0],
  ["nm_c",0],
  ["nm_cpp",0],
  ["nm_d8",0],
  ["nm_deno",0],
  ["nm_llrt",0],
  ["nm_nodejs",0],
  ["nm_python",0],
  */
["nm_qjs", 0], /*
  ["nm_rust",0],
  ["nm_shermes",0],
  ["nm_spidermonkey",0],
  ["nm_tjs",0],
  ["nm_typescript",0],
  ["nm_wasm",0]
  */
]);
for (const [runtime] of runtimes) {
  try {
    const {resolve, reject, promise} = Promise.withResolvers();
    const now = performance.now();
    const input = Array(209715 * 64);
    let len = input.length;
    let bytes = 0;
    const port = chrome.runtime.connectNative(runtime);
    port.onMessage.addListener( (message) => {
      //console.assert(message.length === 209715, {message, runtime});
      bytes += message.length;
      if (bytes === len) {
        runtimes.set(runtime, (performance.now() - now) / 1000);
        port.disconnect();
        resolve();
      }
    }
    );
    port.onDisconnect.addListener( () => reject(chrome.runtime.lastError));
    port.postMessage(input);
    if (runtime === "nm_spidermonkey") {
      port.postMessage("\r\n\r\n");
    }
    await promise;
  } catch (e) {
    console.log(e, runtime);
    continue;
  }
}
var sorted = [...runtimes].sort( ([,a], [,b]) => a < b ? -1 : a === b ? 0 : 1);
console.table(sorted);

Gemini

0    'nm_qjs'    4.778599999994039

guest271314

0    'nm_qjs'    37.553

#!/usr/bin/env -S /home/user/bin/qjs -m --std

function getMessage() {
  const header = new Uint32Array(1);
  std.in.read(header.buffer, 0, 4);
  const output = new Uint8Array(header[0]);
  const len = std.in.read(output.buffer, 0, output.length);
  return output;
}

function sendMessage(message) {
  // Constants for readability
  const COMMA = 44;
  const OPEN_BRACKET = 91; // [
  const CLOSE_BRACKET = 93; // ]
  const CHUNK_SIZE = 1024 * 1024; // 1MB

  // If small enough, send directly (Native endianness handling recommended)
  if (message.length <= CHUNK_SIZE) {
    writeChunk(message);
    return;
  }

  let index = 0;

  // Iterate through the message until we reach the end
  while (index < message.length) {
    let splitIndex;

    // 1. Determine where to cut the chunk
    // Try to jump forward 1MB
    let searchStart = index + CHUNK_SIZE - 8;

    if (searchStart >= message.length) {
      // We are near the end, take everything remaining
      splitIndex = message.length;
    } else {
      // Find the next safe comma to split on
      splitIndex = message.indexOf(COMMA, searchStart);
      if (splitIndex === -1) {
        splitIndex = message.length; // No more commas, take the rest
      }
    }

    // 2. Extract the raw chunk (No copy yet, just a view)
    const rawChunk = message.subarray(index, splitIndex);

    // 3. Prepare the final payload buffer
    // We calculate size first to allocate exactly once per chunk
    const startByte = rawChunk[0];
    const endByte = rawChunk[rawChunk.length - 1];

    let prepend = null;
    let append = null;

    // Logic to ensure every chunk is a valid JSON array [...]
    // Case A: Starts with '[' (First chunk), needs ']' at end if not present
    if (startByte === OPEN_BRACKET && endByte !== CLOSE_BRACKET) {
      append = CLOSE_BRACKET;
    } // Case B: Starts with ',' (Middle chunks), needs '[' at start
    else if (startByte === COMMA) {
      prepend = OPEN_BRACKET;

      // If it doesn't end with ']', it needs one
      if (endByte !== CLOSE_BRACKET) {
        append = CLOSE_BRACKET;
      }
      // Note: We skip the leading comma in the raw copy later by offsetting
    }

    // 4. Construct the output buffer
    // Calculate final length: Header (4) + (Prepend?) + Body + (Append?)
    // Note: If startByte was COMMA, we usually want to overwrite it with '[',
    // but your original logic kept the comma data or shifted.
    // Standard approach:
    // If raw starts with comma, we replace comma with '[' or insert '['?
    // Your logic: Replaced [0] if it was comma.

    // Optimized construction based on your logic pattern:
    let bodyLength = rawChunk.length;
    let payloadOffset = 4; // Start after 4-byte header

    // Adjust sizes based on brackets
    const hasPrepend = prepend !== null;
    const hasAppend = append !== null;

    // Special handling for the "Comma Start" case to match your logic:
    // Your logic: x[0] = 91; x[i] = data[i]. Effectively replaces comma with '['
    let sourceOffset = 0;
    if (startByte === COMMA) {
      sourceOffset = 1; // Skip the comma from source
      bodyLength -= 1; // Reduce source len
      // We implicitly assume we prepend '[' in this slot
    }

    const totalLength = 4 + (hasPrepend ? 1 : 0) + bodyLength +
      (hasAppend ? 1 : 0);
    const output = new Uint8Array(totalLength);

    // Write Length Header (Little Endian example)
    const dataLen = totalLength - 4;
    output[0] = (dataLen >> 0) & 0xff;
    output[1] = (dataLen >> 8) & 0xff;
    output[2] = (dataLen >> 16) & 0xff;
    output[3] = (dataLen >> 24) & 0xff;

    // Write Prepend (e.g. '[')
    let cursor = 4;
    if (hasPrepend) {
      output[cursor] = prepend;
      cursor++;
    } else if (startByte === COMMA) {
      // If we didn't flag prepend but stripped comma, likely need bracket
      // Based on your specific logic "x[0] = 91", we treat that as a prepend
      output[cursor] = OPEN_BRACKET;
      cursor++;
    }

    // Write Body (Fast copy)
    // We use .set() which is much faster than a loop
    output.set(rawChunk.subarray(sourceOffset), cursor);
    cursor += bodyLength;

    // Write Append (e.g. ']')
    if (hasAppend) {
      output[cursor] = append;
    }

    // 5. Send immediately
    std.out.write(output.buffer, 0, output.length);
    std.out.flush();

    // Force GC only occasionally if needed (every chunk is often too frequent)
    std.gc();

    // Move index for next iteration
    index = splitIndex;
  }
}

// Helper for the simple case (writes 4-byte header + data)
function writeChunk(data) {
  const header = new Uint8Array(4);
  header[0] = (data.length >> 0) & 0xff;
  header[1] = (data.length >> 8) & 0xff;
  header[2] = (data.length >> 16) & 0xff;
  header[3] = (data.length >> 24) & 0xff;

  // Two writes are often better than allocating a new joined buffer
  // if the engine supports it. If not, combine them.
  const output = new Uint8Array(4 + data.length);
  output.set(header, 0);
  output.set(data, 4);
  std.out.write(output.buffer, 0, output.length);
  std.out.flush();
}

function main() {
  while (true) {
    const message = getMessage();
    sendMessage(message);
  }
}

try {
  main();
} catch (e) {
  // std.writeFile("err.txt", e.message);
  std.exit(0);
}