From 8f9060c6dcc747f4cffa6b89b7a1a5b7c914b10b Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Thu, 4 Jan 2018 21:37:51 +0100
Subject: [PATCH] benchmark: add JSStreamWrap benchmark

This is made to mirror the connection-bound net benchmarks.

PR-URL: https://github.com/nodejs/node/pull/17983
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../net/net-wrap-js-stream-passthrough.js     | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 benchmark/net/net-wrap-js-stream-passthrough.js

diff --git a/benchmark/net/net-wrap-js-stream-passthrough.js b/benchmark/net/net-wrap-js-stream-passthrough.js
new file mode 100644
index 00000000000000..bf84285e81b53a
--- /dev/null
+++ b/benchmark/net/net-wrap-js-stream-passthrough.js
@@ -0,0 +1,107 @@
+// test the speed of .pipe() with JSStream wrapping for PassThrough streams
+'use strict';
+
+const common = require('../common.js');
+const { PassThrough } = require('stream');
+
+const bench = common.createBenchmark(main, {
+  len: [102400, 1024 * 1024 * 16],
+  type: ['utf', 'asc', 'buf'],
+  dur: [5],
+}, {
+  flags: ['--expose-internals']
+});
+
+var dur;
+var len;
+var type;
+var chunk;
+var encoding;
+var JSStreamWrap;  // Can only require internals inside main().
+
+function main(conf) {
+  dur = +conf.dur;
+  len = +conf.len;
+  type = conf.type;
+  JSStreamWrap = require('internal/wrap_js_stream');
+
+  switch (type) {
+    case 'buf':
+      chunk = Buffer.alloc(len, 'x');
+      break;
+    case 'utf':
+      encoding = 'utf8';
+      chunk = 'ü'.repeat(len / 2);
+      break;
+    case 'asc':
+      encoding = 'ascii';
+      chunk = 'x'.repeat(len);
+      break;
+    default:
+      throw new Error(`invalid type: ${type}`);
+  }
+
+  doBenchmark();
+}
+
+function Writer() {
+  this.received = 0;
+  this.writable = true;
+}
+
+Writer.prototype.write = function(chunk, encoding, cb) {
+  this.received += chunk.length;
+
+  if (typeof encoding === 'function')
+    encoding();
+  else if (typeof cb === 'function')
+    cb();
+
+  return true;
+};
+
+// doesn't matter, never emits anything.
+Writer.prototype.on = function() {};
+Writer.prototype.once = function() {};
+Writer.prototype.emit = function() {};
+Writer.prototype.prependListener = function() {};
+
+
+function flow() {
+  const dest = this.dest;
+  const res = dest.write(chunk, encoding);
+  if (!res)
+    dest.once('drain', this.flow);
+  else
+    process.nextTick(this.flow);
+}
+
+function Reader() {
+  this.flow = flow.bind(this);
+  this.readable = true;
+}
+
+Reader.prototype.pipe = function(dest) {
+  this.dest = dest;
+  this.flow();
+  return dest;
+};
+
+
+function doBenchmark() {
+  const reader = new Reader();
+  const writer = new Writer();
+
+  // the actual benchmark.
+  const fakeSocket = new JSStreamWrap(new PassThrough());
+  bench.start();
+  reader.pipe(fakeSocket);
+  fakeSocket.pipe(writer);
+
+  setTimeout(function() {
+    const bytes = writer.received;
+    const gbits = (bytes * 8) / (1024 * 1024 * 1024);
+    bench.end(gbits);
+    process.exit(0);
+  }, dur * 1000);
+}