http: improve performance with known-length calls to end()

This boosts RPS performance for the common API case where you call
`res.end(data)` with the entire response by up to 9%.
Signed-off-by: Tim Perry <pimterry@gmail.com>
PR-URL: #65466
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>

Author: pimterry

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);

benchmark/http/end-string.js

@@ -0,0 +1,35 @@
+// Responses sent as a single res.end(string) with a known Content-Length -
+// the shape a JSON or HTML endpoint produces.
+'use strict';
+
+constcommon=require('../common.js');
+
+constbench=common.createBenchmark(main,{
+len: [4,64,1024,16384,102400],
+c: [50],
+duration: 5,
+});
+
+functionmain({ len, c, duration }){
+consthttp=require('http');
+constbody='a'.repeat(len);
+constheaders={
+'Content-Type': 'text/plain',
+'Content-Length': `${len}`,
+};
+
+constserver=http.createServer((req,res)=>{
+res.writeHead(200,headers);
+res.end(body);
+});
+
+server.listen(0,()=>{
+bench.http({
+connections: c,
+ duration,
+port: server.address().port,
+},()=>{
+server.close();
+});
+});
+}

lib/_http_outgoing.js

@@ -1026,6 +1026,25 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
 }
 
 
+// If this last write can be delivered immediately as the final chunk, this
+// prepares to do so, and then returns true. If not, it returns false and
+// a separate _send call and tick will be required to finish up.
+functionmaybePrepareFinalChunk(msg,chunk,encoding){
+if(typeofchunk!=='string'&&!isUint8Array(chunk))
+returnfalse;
+
+if(msg.destroyed||msg.strictContentLength)
+returnfalse;
+
+if(!msg._header){
+msg._contentLength=typeofchunk==='string' ?
+Buffer.byteLength(chunk,encoding) : chunk.byteLength;
+msg._implicitHeader();
+}
+
+return!!msg._header&&msg._hasBody&&!msg.chunkedEncoding;
+}
+
 functionconnectionCorkNT(conn){
 conn.uncork();
 }
@@ -1131,6 +1150,8 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 encoding=null;
 }
 
+letfinishCallback=null;
+
 if(chunk){
 if(this.finished){
 onError(this,
@@ -1143,7 +1164,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 this[kSocket].cork();
 }
 
-write_(this,chunk,encoding,null,true);
+if(maybePrepareFinalChunk(this,chunk,encoding)){
+// If just one final write is required, with nothing to follow, we
+// attach finish to the write to avoid a separate send() & tick step
+// later on - this is purely a performance optimization.
+if(typeofcallback==='function'){
+queueEndCallback(this,callback);
+callback=undefined;
+}
+finishCallback=onFinish.bind(undefined,this);
+}
+
+write_(this,chunk,encoding,finishCallback,true);
 }elseif(this.finished){
 if(typeofcallback==='function'){
 queueEndCallback(this,callback);
@@ -1165,14 +1197,17 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 thrownewERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten],this._contentLength);
 }
 
-constfinish=onFinish.bind(undefined,this);
+if(finishCallback===null){
+// If we didn't early finish, send the last data and schedule 'finish' now:
+finishCallback=onFinish.bind(undefined,this);
 
-if(this._hasBody&&this.chunkedEncoding){
-this._send('0\r\n'+this._trailer+'\r\n','latin1',finish);
-}elseif(!this._headerSent||this.writableLength||chunk){
-this._send('','latin1',finish);
-}else{
-process.nextTick(finish);
+if(this._hasBody&&this.chunkedEncoding){
+this._send('0\r\n'+this._trailer+'\r\n','latin1',finishCallback);
+}elseif(!this._headerSent||this.writableLength||chunk){
+this._send('','latin1',finishCallback);
+}else{
+process.nextTick(finishCallback);
+}
 }
 
 if(this[kSocket]){

test/parallel/test-http-server-response-standalone.js

@@ -15,18 +15,11 @@ const res = new ServerResponse({
 httpVersionMinor: 1
 });
 
-letfirstChunk=true;
-
 constws=newWritable({
 write: common.mustCall((chunk,encoding,callback)=>{
-if(firstChunk){
-assert(chunk.toString().endsWith('hello world'));
-firstChunk=false;
-}else{
-assert.strictEqual(chunk.length,0);
-}
+assert(chunk.toString().endsWith('hello world'));
 setImmediate(callback);
-},2)
+},1)
 });
 
 res.assignSocket(ws);