Faster `Transform` stream

[ronag]

Some thoughts on how to make Transform streams faster.

Part of the overhead of Transform (and PassThrough) is that it is actually 2 streams, one Writable and one Readable, both with buffering and state management, which are connected together.

We could try to skip this and implement Transform as a Readable which implements the Writable interface and proxies the naming.

e.g.

class FastTransform extends Readable {
 constructor(options) {
 super(options)
 this._writableState = {
 length: 0,
 needDrain: false,
 ended: false,
 finished: false
 }
 }
 get writableEnded () {
 return this._writableState.ended
 }
 get writableFinished () {
 return this._writableState.finished
 }
 _read () {
 const rState = this._readableState
 const wState = this._writableState

 if (!wState.needDrain) {
 return
 }

 if (wState.length + rState.length > rState.highWaterMark) {
 return
 }

 wState.needDrain = false
 this.emit('drain')
 }
 write (chunk) {
 const rState = this._readableState
 const wState = this._writableState

 const len = chunk.length

 wState.length += len
 this._transform(chunk, null, (err, data) => {
 wState.length -= len
 if (err) {
 this.destroy(err)
 } else if (data != null) {
 this.push(data)
 }
 this._read()
 })

 wState.needDrain = wState.length + rState.length > rState.highWaterMark

 return wState.needDrain
 }
 end () {
 const wState = this._writableState

 wState.ended = true
 if (this._flush) {
 this._flush(chunk, (err, data) => {
 const wState = this._writableState
 if (err) {
 this.destroy(err)
 } else {
 if (data != null) {
 this.push(data)
 }
 this.push(null)
 wState.finished = true
 this.emit('finish')
 }
 })
 } else {
 this.push(null)
 wState.finished = true
 this.emit('finish')
 }
 }
}

// TODO: Make Writable[Symbol.hasInstance] recognize `FastTransform`.

Making this fully backwards compatible with Transform might be difficult.

[ronag]

Thoughts @nodejs/streams?

[mcollina]

How much will we gain from this? I'm +1, possibly with a better name.

[ronag]

@mcollina: ~60%

$ time node fast-transform.js 

real 0m1.582s
user 0m1.737s
sys 0m0.157s

$ time node transform.js 

real 0m2.671s
user 0m2.683s
sys 0m0.069s
undici$ 

possibly with a better name.

FasterTransform? 😄

[targos]

How does it compare to transforming with an async generator function?

[ronag]

$ time node async-generator.js 
real 0m0.788s
user 0m0.772s
sys 0m0.075s

$ time node fast-transform.js 
real 0m1.612s
user 0m1.729s
sys 0m0.169s

So using an async generator in pipeline might be significantly faster. Is it worth further optimizing Transform? Note that an optimization as suggested here does make it harder to maintain than today's rather trivial implementation.

[ronag]

pipeline will convert a Readable source into an async iterator and read from it that way. Might introduce unnecessary overhead. Will investigate that first.

[clshortfuse]

Apparently I should be using pipeline. This does seem like a good replacement for PassThrough.