buffer: speed up swap16/32, add swap64

* Speed up buffer.swap16 and swap32 by using builtins. Up to ~6x gain.
Drop transition point between JS and C++ implementations accordingly.
Amount of performance improvement not only depends on buffer size but
also memory alignment.
* Fix tests: C++ impl tests were testing 0-filled buffers so were
always passing.
* Add similar buffer.swap64 method.
* Make buffer-swap benchmark mirror JS impl.
doc/api/buffer.markdown has an entry of "added: REPLACEME" that should
be changed to the correct release number before tagged.
Because node is currently using a very old version of cpplint.py it
doesn't know that std::swap() has moved from <algorithm> to <utility> in
c++11. So until cpplint.py is updated simply NOLINT the line.
Technically it should be NOLINT(build/include_what_you_use), but that
puts the line over 80 characters causing another lint error.
PR-URL: #7157
Reviewed-By: Trevor Norris <trev.norris@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Backport-URL: #7546

Author: zbjornson

benchmark/buffers/buffer-swap.js

@@ -1,61 +1,90 @@
 'use strict';
 
 constcommon=require('../common.js');
+constv8=require('v8');
 
 constbench=common.createBenchmark(main,{
-method: ['swap16','swap32','htons','htonl'],
-len: [4,64,512,768,1024,1536,2056,4096,8192],
-n: [1e6]
+aligned: ['true','false'],
+method: ['swap16','swap32','swap64'/*, 'htons', 'htonl', 'htonll'*/],
+len: [8,64,128,256,512,768,1024,1536,2056,4096,8192],
+n: [5e7]
 });
 
 // The htons and htonl methods below are used to benchmark the
 // performance difference between doing the byteswap in pure
 // javascript regardless of Buffer size as opposed to dropping
-// down to the native layer for larger Buffer sizes.
+// down to the native layer for larger Buffer sizes. Commented
+// out by default because they are slow for big buffers. If
+// re-evaluating the crossover point, uncomment those methods
+// and comment out their implementations in lib/buffer.js so
+// C++ version will always be used.
+
+functionswap(b,n,m){
+consti=b[n];
+b[n]=b[m];
+b[m]=i;
+}
 
 Buffer.prototype.htons=functionhtons(){
 if(this.length%2!==0)
 thrownewRangeError();
-for(vari=0,n=0;i<this.length;i+=2){
-n=this[i];
-this[i]=this[i+1];
-this[i+1]=n;
+for(vari=0;i<this.length;i+=2){
+swap(this,i,i+1);
 }
 returnthis;
 };
 
 Buffer.prototype.htonl=functionhtonl(){
-if(this.length%2!==0)
+if(this.length%4!==0)
+thrownewRangeError();
+for(vari=0;i<this.length;i+=4){
+swap(this,i,i+3);
+swap(this,i+1,i+2);
+}
+returnthis;
+};
+
+Buffer.prototype.htonll=functionhtonl(){
+if(this.length%8!==0)
 thrownewRangeError();
-for(vari=0,n=0;i<this.length;i+=4){
-n=this[i];
-this[i]=this[i+3];
-this[i+3]=n;
-n=this[i+1];
-this[i+1]=this[i+2];
-this[i+2]=n;
+for(vari=0;i<this.length;i+=8){
+swap(this,i,i+7);
+swap(this,i+1,i+6);
+swap(this,i+2,i+5);
+swap(this,i+3,i+4);
 }
 returnthis;
 };
 
-functioncreateBuffer(len){
+functioncreateBuffer(len,aligned){
+len+=aligned ? 0 : 1;
 constbuf=Buffer.allocUnsafe(len);
 for(vari=1;i<=len;i++)
 buf[i-1]=i;
-returnbuf;
+returnaligned ? buf : buf.slice(1);
 }
 
-functionbufferSwap(n,buf,method){
-for(vari=1;i<=n;i++)
-buf[method]();
+functiongenMethod(method){
+constfnString=
+'return function '+method+'(n, buf) {'+
+' for (var i = 0; i <= n; i++)'+
+' buf.'+method+'();'+
+'}';
+return(newFunction(fnString))();
 }
 
 functionmain(conf){
 constmethod=conf.method;
 constlen=conf.len|0;
 constn=conf.n|0;
-constbuf=createBuffer(len);
+constaligned=conf.aligned||'true';
+constbuf=createBuffer(len,aligned==='true');
+constbufferSwap=genMethod(method);
+
+v8.setFlagsFromString('--allow_natives_syntax');
+eval('%OptimizeFunctionOnNextCall(bufferSwap)');
+
 bench.start();
-bufferSwap(n,buf,method);
+bufferSwap(n,buf);
 bench.end(n);
 }

doc/api/buffer.md

@@ -1461,10 +1461,10 @@ calls can be chained.
 ```js
 constbuf=Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
 console.log(buf);
-// Prints Buffer(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8)
+// Prints <Buffer 01 02 03 04 05 06 07 08>
 buf.swap16();
 console.log(buf);
-// Prints Buffer(0x2, 0x1, 0x4, 0x3, 0x6, 0x5, 0x8, 0x7)
+// Prints <Buffer 02 01 04 03 06 05 08 07>
 ```
 
 ### buf.swap32()
@@ -1482,12 +1482,36 @@ calls can be chained.
 ```js
 constbuf=Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
 console.log(buf);
-// Prints Buffer(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8)
+// Prints <Buffer 01 02 03 04 05 06 07 08>
 buf.swap32();
 console.log(buf);
-// Prints Buffer(0x4, 0x3, 0x2, 0x1, 0x8, 0x7, 0x6, 0x5)
+// Prints <Buffer 04 03 02 01 08 07 06 05>
 ```
 
+### buf.swap64()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Return: {Buffer}
+
+Interprets the `Buffer` as an array of 64-bit numbers and swaps
+the byte-order *in-place*. Throws a `RangeError` if the `Buffer` length is
+not a multiple of 64 bits. The method returns a reference to the Buffer, so
+calls can be chained.
+
+```js
+constbuf=Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
+console.log(buf);
+// Prints <Buffer 01 02 03 04 05 06 07 08>
+buf.swap64();
+console.log(buf);
+// Prints <Buffer 08 07 06 05 04 03 02 01>
+```
+
+Note that JavaScript cannot encode 64-bit integers. This method is intended
+for working with 64-bit floats.
+
 ### buf.toString([encoding[, start[, end]]])
 
 *`encoding` {String} Default: `'utf8'`

lib/buffer.js

@@ -24,47 +24,6 @@ var poolSize, poolOffset, allocPool;
 
 binding.setupBufferJS(Buffer.prototype,bindingObj);
 
-constswap16n=binding.swap16;
-constswap32n=binding.swap32;
-
-functionswap(b,n,m){
-consti=b[n];
-b[n]=b[m];
-b[m]=i;
-}
-
-Buffer.prototype.swap16=functionswap16(){
-// For Buffer.length < 512, it's generally faster to
-// do the swap in javascript. For larger buffers,
-// dropping down to the native code is faster.
-constlen=this.length;
-if(len%2!==0)
-thrownewRangeError('Buffer size must be a multiple of 16-bits');
-if(len<512){
-for(vari=0;i<len;i+=2)
-swap(this,i,i+1);
-returnthis;
-}
-returnswap16n.apply(this);
-};
-
-Buffer.prototype.swap32=functionswap32(){
-// For Buffer.length < 1024, it's generally faster to
-// do the swap in javascript. For larger buffers,
-// dropping down to the native code is faster.
-constlen=this.length;
-if(len%4!==0)
-thrownewRangeError('Buffer size must be a multiple of 32-bits');
-if(len<1024){
-for(vari=0;i<len;i+=4){
-swap(this,i,i+3);
-swap(this,i+1,i+2);
-}
-returnthis;
-}
-returnswap32n.apply(this);
-};
-
 constflags=bindingObj.flags;
 constkNoZeroFill=0;
 
@@ -1320,3 +1279,67 @@ Buffer.prototype.writeDoubleBE = function writeDoubleBE(val, offset, noAssert) {
 binding.writeDoubleBE(this,val,offset,true);
 returnoffset+8;
 };
+
+constswap16n=binding.swap16;
+constswap32n=binding.swap32;
+constswap64n=binding.swap64;
+
+functionswap(b,n,m){
+consti=b[n];
+b[n]=b[m];
+b[m]=i;
+}
+
+
+Buffer.prototype.swap16=functionswap16(){
+// For Buffer.length < 128, it's generally faster to
+// do the swap in javascript. For larger buffers,
+// dropping down to the native code is faster.
+constlen=this.length;
+if(len%2!==0)
+thrownewRangeError('Buffer size must be a multiple of 16-bits');
+if(len<128){
+for(vari=0;i<len;i+=2)
+swap(this,i,i+1);
+returnthis;
+}
+returnswap16n(this);
+};
+
+
+Buffer.prototype.swap32=functionswap32(){
+// For Buffer.length < 192, it's generally faster to
+// do the swap in javascript. For larger buffers,
+// dropping down to the native code is faster.
+constlen=this.length;
+if(len%4!==0)
+thrownewRangeError('Buffer size must be a multiple of 32-bits');
+if(len<192){
+for(vari=0;i<len;i+=4){
+swap(this,i,i+3);
+swap(this,i+1,i+2);
+}
+returnthis;
+}
+returnswap32n(this);
+};
+
+
+Buffer.prototype.swap64=functionswap64(){
+// For Buffer.length < 192, it's generally faster to
+// do the swap in javascript. For larger buffers,
+// dropping down to the native code is faster.
+constlen=this.length;
+if(len%8!==0)
+thrownewRangeError('Buffer size must be a multiple of 64-bits');
+if(len<192){
+for(vari=0;i<len;i+=8){
+swap(this,i,i+7);
+swap(this,i+1,i+6);
+swap(this,i+2,i+5);
+swap(this,i+3,i+4);
+}
+returnthis;
+}
+returnswap64n(this);
+};