`asJson` to `Buffer`

[ronag]

I think there could be a potential fast path by having asJSON write into a buffer and send that to stream.write.

[jsumners]

I might be misunderstanding the implementation you have in mind. A while back I wondered if this pattern could be improved with a buffer:

let buf = ''
function someStreamDataHandler(data, enc, cb) {
  buf += data.toString()
  cb()
}

Supposed improvement (trying to keep everything in Buffer land until it needs to be a string):

let buf = Buffer.alloc(0)
function someStreamDataHandler(data, enc, cb) {
  buf = Buffer.concat([buf, data])
  cb()
}

Unfortunately, the buffer version is slower.

Benchmark Script

'use strict'

const assert = require('node:assert')
const { Suite } = require('bench-node')
const suite = new Suite()

const data = Buffer.from('a')
const iterations = 1_000

suite.add('append buffer', () => {
  let buf = Buffer.alloc(0)
  for (let i = 0; i < iterations; i += 1) {
    buf = Buffer.concat([buf, data])
  }
  assert.ok(buf.byteLength >= iterations)
})

suite.add('string append', () => {
  let buf = ''
  for (let i = 0; i < iterations; i += 1) {
    buf = buf + data.toString()
  }
  assert.ok(buf.length >= iterations)
})

suite.run()

Results on my MacBook Pro M1 Max:

❯ node --version && node --allow-natives-syntax index.js
v22.19.0
append buffer                                 x 13,063 ops/sec (10 runs sampled) v8-never-optimize=true min..max=(75.47us...76.47us)
string append                                 x 28,800 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(34.04us...35.61us)

❯ node --version && node --allow-natives-syntax index.js
v24.7.0
append buffer                                 x 7,699 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(126.85us...136.28us)
string append                                 x 28,830 ops/sec (11 runs sampled) v8-never-optimize=true min..max=(33.79us...35.72us)

[ronag]

No that's not what I had in mind.

[ronag]

Pre allocate a big buffer, write to it using Buffer.write and then slice it of and return. No intermediate small strings or buffers.

[mcollina]

I fear that would not yield any performance improvements of any kind. Ultimately it's the same amount of work moved into a different place.

[ronag]

Not quite. I'll try to make a demonstration.

[ronag]

So it seems you are right in terms of performance being roughly the same. But I would still argue that memory usage and gc pressure should be lower (3.06 kb vs 872.36 b):

import { run, bench } from 'mitata'

function asJsonString (obj) {
  let str = ''
  for (const key in obj) {
    str += ',' + JSON.stringify(key) + ':' 

    const value = obj[key]
    switch (typeof value) {
      case 'number':
        str += Number.isFinite(value) === false ? 'null' : String(value)
        break
      case 'boolean':
        str += value ? 'true' : 'false'
        break
      default:
        str+= = JSON.stringify(value)
    }
  }
  return str
}

let poolBuffer = Buffer.allocUnsafe(1024 * 1024)
let poolOffset = 0
let poolLength = poolBuffer.length

const COMMNA = ','.charCodeAt(0)
const COLON = ':'.charCodeAt(0)

function asJsonBuffer(obj) {
  let buf = poolBuffer
  let pos = poolOffset

  for (const key in obj) {
    buf[pos++] = COMMNA
    pos += buf.write(JSON.stringify(key))
    buf[pos++] = COLON

    let value = obj[key]
    switch (typeof value) {
      case 'number':
        value = Number.isFinite(value) ? String(value) : 'null'
        for (let n = 0; n < value.length; n++) {
          buf[pos++] = value.charCodeAt(n)
        }
        break
      case 'boolean':
        value = value ? 'true' : 'false'
        for (let n = 0; n < value.length; n++) {
          buf[pos++] = value.charCodeAt(n)
        }
        break
      default:
        pos += buf.write(JSON.stringify(value))
    }
  }

  if (pos >= poolLength) {
    poolLength = poolOffset === 0 ? poolLength * 2 : poolLength
    poolBuffer = Buffer.allocUnsafeSlow(poolLength)
    poolOffset = 0
    return asJsonBuffer(obj)
  }

  buf = buf.subarray(poolOffset, pos)
  poolOffset = pos
  return buf
}

const randomObj = {
  string: 'hello',
  number: 42,
  boolean: true,
  sdasd: 'sadasd',
  asdasd: 'asdasd',
  asdasd1: 'asdasd',
  asdasd2: 'asdasd',
  asdasd3: 'asdasd',
  asdasd4: 'asdasd',
  asdasd5: 'asdasd',
  asdasd6: 'asdasd',
  ddd: 123,
  ddd1: 123,
  ddd2: 123,
  ddd3: 123,
  ddd4: 123,
}

let counter = 0

bench('asJsonString', () => {
  counter += Buffer.from(asJsonString(randomObj)).length
})


bench('asJsonBuffer', () => {
  counter += asJsonBuffer(randomObj).length
})

await run()

console.log(counter)

benchmark                   avg (min … max) p75 / p99    (min … top 1%)
------------------------------------------- -------------------------------
asJsonString                   2.52 µs/iter   2.53 µs  █                   
                        (2.45 µs … 2.92 µs)   2.80 µs  ██▅                 
                    (  1.22 kb …   3.21 kb)   3.06 kb ████▅▆▄▁▄▂▁▂▂▄▁▁▁▂▂▁▂
                  5.87 ipc (  0.00% stalls)    NaN% L1 data cache
          7.10k cycles  41.63k instructions   0.00% retired LD/ST (   0.00)

asJsonBuffer                   2.54 µs/iter   2.54 µs     █                
                        (2.47 µs … 2.75 µs)   2.74 µs  ▅▂▅█▅               
                    (863.89  b … 877.01  b) 872.36  b ▆█████▆▆▄▃▄▁▃▁▃▁▃▁▁▁▃
                  5.99 ipc (  0.00% stalls)    NaN% L1 data cache
          7.18k cycles  43.02k instructions   0.00% retired LD/ST (   0.00)