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: https://github.com/nodejs/node/pull/7157 Reviewed-By: Trevor Norris <trev.norris@gmail.com> Reviewed-By: James M Snell <jasnell@gmail.com>
This commit is contained in:
Zach Bjornson
Trevor Norris
parent
561548702e
commit
a1059afd39
@ -1,61 +1,90 @@
|
||||
'use strict';
|
||||
|
||||
const common = require('../common.js');
|
||||
const v8 = require('v8');
|
||||
|
||||
const bench = 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.
|
||||
|
||||
function swap(b, n, m) {
|
||||
const i = b[n];
|
||||
b[n] = b[m];
|
||||
b[m] = i;
|
||||
}
|
||||
|
||||
Buffer.prototype.htons = function htons() {
|
||||
if (this.length % 2 !== 0)
|
||||
throw new RangeError();
|
||||
for (var i = 0, n = 0; i < this.length; i += 2) {
|
||||
n = this[i];
|
||||
this[i] = this[i + 1];
|
||||
this[i + 1] = n;
|
||||
for (var i = 0; i < this.length; i += 2) {
|
||||
swap(this, i, i + 1);
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
Buffer.prototype.htonl = function htonl() {
|
||||
if (this.length % 2 !== 0)
|
||||
if (this.length % 4 !== 0)
|
||||
throw new RangeError();
|
||||
for (var i = 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 (var i = 0; i < this.length; i += 4) {
|
||||
swap(this, i, i + 3);
|
||||
swap(this, i + 1, i + 2);
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
function createBuffer(len) {
|
||||
Buffer.prototype.htonll = function htonl() {
|
||||
if (this.length % 8 !== 0)
|
||||
throw new RangeError();
|
||||
for (var i = 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);
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
function createBuffer(len, aligned) {
|
||||
len += aligned ? 0 : 1;
|
||||
const buf = Buffer.allocUnsafe(len);
|
||||
for (var i = 1; i <= len; i++)
|
||||
buf[i - 1] = i;
|
||||
return buf;
|
||||
return aligned ? buf : buf.slice(1);
|
||||
}
|
||||
|
||||
function bufferSwap(n, buf, method) {
|
||||
for (var i = 1; i <= n; i++)
|
||||
buf[method]();
|
||||
function genMethod(method) {
|
||||
const fnString =
|
||||
'return function ' + method + '(n, buf) {' +
|
||||
' for (var i = 0; i <= n; i++)' +
|
||||
' buf.' + method + '();' +
|
||||
'}';
|
||||
return (new Function(fnString))();
|
||||
}
|
||||
|
||||
function main(conf) {
|
||||
const method = conf.method;
|
||||
const len = conf.len | 0;
|
||||
const n = conf.n | 0;
|
||||
const buf = createBuffer(len);
|
||||
const aligned = conf.aligned || 'true';
|
||||
const buf = createBuffer(len, aligned === 'true');
|
||||
const bufferSwap = genMethod(method);
|
||||
|
||||
v8.setFlagsFromString('--allow_natives_syntax');
|
||||
eval('%OptimizeFunctionOnNextCall(bufferSwap)');
|
||||
|
||||
bench.start();
|
||||
bufferSwap(n, buf, method);
|
||||
bufferSwap(n, buf);
|
||||
bench.end(n);
|
||||
}
|
||||
|
||||
@ -1470,10 +1470,10 @@ calls can be chained.
|
||||
```js
|
||||
const buf = 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()
|
||||
@ -1491,12 +1491,36 @@ calls can be chained.
|
||||
```js
|
||||
const buf = 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
|
||||
const buf = 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'`
|
||||
|
||||
105
lib/buffer.js
105
lib/buffer.js
@ -25,47 +25,6 @@ var poolSize, poolOffset, allocPool;
|
||||
|
||||
binding.setupBufferJS(Buffer.prototype, bindingObj);
|
||||
|
||||
const swap16n = binding.swap16;
|
||||
const swap32n = binding.swap32;
|
||||
|
||||
function swap(b, n, m) {
|
||||
const i = b[n];
|
||||
b[n] = b[m];
|
||||
b[m] = i;
|
||||
}
|
||||
|
||||
Buffer.prototype.swap16 = function swap16() {
|
||||
// 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.
|
||||
const len = this.length;
|
||||
if (len % 2 !== 0)
|
||||
throw new RangeError('Buffer size must be a multiple of 16-bits');
|
||||
if (len < 512) {
|
||||
for (var i = 0; i < len; i += 2)
|
||||
swap(this, i, i + 1);
|
||||
return this;
|
||||
}
|
||||
return swap16n.apply(this);
|
||||
};
|
||||
|
||||
Buffer.prototype.swap32 = function swap32() {
|
||||
// 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.
|
||||
const len = this.length;
|
||||
if (len % 4 !== 0)
|
||||
throw new RangeError('Buffer size must be a multiple of 32-bits');
|
||||
if (len < 1024) {
|
||||
for (var i = 0; i < len; i += 4) {
|
||||
swap(this, i, i + 3);
|
||||
swap(this, i + 1, i + 2);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
return swap32n.apply(this);
|
||||
};
|
||||
|
||||
// |binding.zeroFill| can be undefined when running inside an isolate where we
|
||||
// do not own the ArrayBuffer allocator. Zero fill is always on in that case.
|
||||
const zeroFill = bindingObj.zeroFill || [0];
|
||||
@ -1303,3 +1262,67 @@ Buffer.prototype.writeDoubleBE = function writeDoubleBE(val, offset, noAssert) {
|
||||
binding.writeDoubleBE(this, val, offset, true);
|
||||
return offset + 8;
|
||||
};
|
||||
|
||||
const swap16n = binding.swap16;
|
||||
const swap32n = binding.swap32;
|
||||
const swap64n = binding.swap64;
|
||||
|
||||
function swap(b, n, m) {
|
||||
const i = b[n];
|
||||
b[n] = b[m];
|
||||
b[m] = i;
|
||||
}
|
||||
|
||||
|
||||
Buffer.prototype.swap16 = function swap16() {
|
||||
// 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.
|
||||
const len = this.length;
|
||||
if (len % 2 !== 0)
|
||||
throw new RangeError('Buffer size must be a multiple of 16-bits');
|
||||
if (len < 128) {
|
||||
for (var i = 0; i < len; i += 2)
|
||||
swap(this, i, i + 1);
|
||||
return this;
|
||||
}
|
||||
return swap16n(this);
|
||||
};
|
||||
|
||||
|
||||
Buffer.prototype.swap32 = function swap32() {
|
||||
// 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.
|
||||
const len = this.length;
|
||||
if (len % 4 !== 0)
|
||||
throw new RangeError('Buffer size must be a multiple of 32-bits');
|
||||
if (len < 192) {
|
||||
for (var i = 0; i < len; i += 4) {
|
||||
swap(this, i, i + 3);
|
||||
swap(this, i + 1, i + 2);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
return swap32n(this);
|
||||
};
|
||||
|
||||
|
||||
Buffer.prototype.swap64 = function swap64() {
|
||||
// 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.
|
||||
const len = this.length;
|
||||
if (len % 8 !== 0)
|
||||
throw new RangeError('Buffer size must be a multiple of 64-bits');
|
||||
if (len < 192) {
|
||||
for (var i = 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);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
return swap64n(this);
|
||||
};
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <utility>
|
||||
|
||||
#define BUFFER_ID 0xB0E4
|
||||
|
||||
@ -51,12 +52,37 @@
|
||||
#define BUFFER_MALLOC(length) \
|
||||
zero_fill_all_buffers ? calloc(length, 1) : malloc(length)
|
||||
|
||||
#define SWAP_BYTES(arr, a, b) \
|
||||
do { \
|
||||
const uint8_t lo = arr[a]; \
|
||||
arr[a] = arr[b]; \
|
||||
arr[b] = lo; \
|
||||
} while (0)
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
#define BSWAP_INTRINSIC_2(x) __builtin_bswap16(x)
|
||||
#define BSWAP_INTRINSIC_4(x) __builtin_bswap32(x)
|
||||
#define BSWAP_INTRINSIC_8(x) __builtin_bswap64(x)
|
||||
#elif defined(__linux__)
|
||||
#include <byteswap.h>
|
||||
#define BSWAP_INTRINSIC_2(x) bswap_16(x)
|
||||
#define BSWAP_INTRINSIC_4(x) bswap_32(x)
|
||||
#define BSWAP_INTRINSIC_8(x) bswap_64(x)
|
||||
#elif defined(_MSC_VER)
|
||||
#include <intrin.h>
|
||||
#define BSWAP_INTRINSIC_2(x) _byteswap_ushort(x);
|
||||
#define BSWAP_INTRINSIC_4(x) _byteswap_ulong(x);
|
||||
#define BSWAP_INTRINSIC_8(x) _byteswap_uint64(x);
|
||||
#else
|
||||
#define BSWAP_INTRINSIC_2(x) ((x) << 8) | ((x) >> 8)
|
||||
#define BSWAP_INTRINSIC_4(x) \
|
||||
(((x) & 0xFF) << 24) | \
|
||||
(((x) & 0xFF00) << 8) | \
|
||||
(((x) >> 8) & 0xFF00) | \
|
||||
(((x) >> 24) & 0xFF)
|
||||
#define BSWAP_INTRINSIC_8(x) \
|
||||
(((x) & 0xFF00000000000000ull) >> 56) | \
|
||||
(((x) & 0x00FF000000000000ull) >> 40) | \
|
||||
(((x) & 0x0000FF0000000000ull) >> 24) | \
|
||||
(((x) & 0x000000FF00000000ull) >> 8) | \
|
||||
(((x) & 0x00000000FF000000ull) << 8) | \
|
||||
(((x) & 0x0000000000FF0000ull) << 24) | \
|
||||
(((x) & 0x000000000000FF00ull) << 40) | \
|
||||
(((x) & 0x00000000000000FFull) << 56)
|
||||
#endif
|
||||
|
||||
namespace node {
|
||||
|
||||
@ -1150,29 +1176,88 @@ void IndexOfNumber(const FunctionCallbackInfo<Value>& args) {
|
||||
: -1);
|
||||
}
|
||||
|
||||
|
||||
void Swap16(const FunctionCallbackInfo<Value>& args) {
|
||||
Environment* env = Environment::GetCurrent(args);
|
||||
THROW_AND_RETURN_UNLESS_BUFFER(env, args.This());
|
||||
SPREAD_ARG(args.This(), ts_obj);
|
||||
THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
|
||||
SPREAD_ARG(args[0], ts_obj);
|
||||
|
||||
for (size_t i = 0; i < ts_obj_length; i += 2) {
|
||||
SWAP_BYTES(ts_obj_data, i, i + 1);
|
||||
CHECK_EQ(ts_obj_length % 2, 0);
|
||||
|
||||
int align = reinterpret_cast<uintptr_t>(ts_obj_data) % sizeof(uint16_t);
|
||||
|
||||
if (align == 0) {
|
||||
uint16_t* data16 = reinterpret_cast<uint16_t*>(ts_obj_data);
|
||||
size_t len16 = ts_obj_length / 2;
|
||||
for (size_t i = 0; i < len16; i++) {
|
||||
data16[i] = BSWAP_INTRINSIC_2(data16[i]);
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < ts_obj_length; i += 2) {
|
||||
std::swap(ts_obj_data[i], ts_obj_data[i + 1]);
|
||||
}
|
||||
}
|
||||
args.GetReturnValue().Set(args.This());
|
||||
|
||||
args.GetReturnValue().Set(args[0]);
|
||||
}
|
||||
|
||||
|
||||
void Swap32(const FunctionCallbackInfo<Value>& args) {
|
||||
Environment* env = Environment::GetCurrent(args);
|
||||
THROW_AND_RETURN_UNLESS_BUFFER(env, args.This());
|
||||
SPREAD_ARG(args.This(), ts_obj);
|
||||
THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
|
||||
SPREAD_ARG(args[0], ts_obj);
|
||||
|
||||
for (size_t i = 0; i < ts_obj_length; i += 4) {
|
||||
SWAP_BYTES(ts_obj_data, i, i + 3);
|
||||
SWAP_BYTES(ts_obj_data, i + 1, i + 2);
|
||||
CHECK_EQ(ts_obj_length % 4, 0);
|
||||
|
||||
int align = reinterpret_cast<uintptr_t>(ts_obj_data) % sizeof(uint32_t);
|
||||
|
||||
if (align == 0) {
|
||||
uint32_t* data32 = reinterpret_cast<uint32_t*>(ts_obj_data);
|
||||
size_t len32 = ts_obj_length / 4;
|
||||
for (size_t i = 0; i < len32; i++) {
|
||||
data32[i] = BSWAP_INTRINSIC_4(data32[i]);
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < ts_obj_length; i += 4) {
|
||||
std::swap(ts_obj_data[i], ts_obj_data[i + 3]);
|
||||
std::swap(ts_obj_data[i + 1], ts_obj_data[i + 2]);
|
||||
}
|
||||
}
|
||||
args.GetReturnValue().Set(args.This());
|
||||
|
||||
args.GetReturnValue().Set(args[0]);
|
||||
}
|
||||
|
||||
|
||||
void Swap64(const FunctionCallbackInfo<Value>& args) {
|
||||
Environment* env = Environment::GetCurrent(args);
|
||||
THROW_AND_RETURN_UNLESS_BUFFER(env, args[0]);
|
||||
SPREAD_ARG(args[0], ts_obj);
|
||||
|
||||
CHECK_EQ(ts_obj_length % 8, 0);
|
||||
|
||||
int align = reinterpret_cast<uintptr_t>(ts_obj_data) % sizeof(uint64_t);
|
||||
|
||||
if (align == 0) {
|
||||
uint64_t* data64 = reinterpret_cast<uint64_t*>(ts_obj_data);
|
||||
size_t len32 = ts_obj_length / 8;
|
||||
for (size_t i = 0; i < len32; i++) {
|
||||
data64[i] = BSWAP_INTRINSIC_8(data64[i]);
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < ts_obj_length; i += 8) {
|
||||
std::swap(ts_obj_data[i], ts_obj_data[i + 7]);
|
||||
std::swap(ts_obj_data[i + 1], ts_obj_data[i + 6]);
|
||||
std::swap(ts_obj_data[i + 2], ts_obj_data[i + 5]);
|
||||
// NOLINT added because current cpplint.py is old and doesn't know that
|
||||
// std::swap() now lives in <utility> instead of <algorithm>.
|
||||
std::swap(ts_obj_data[i + 3], ts_obj_data[i + 4]); // NOLINT
|
||||
}
|
||||
}
|
||||
|
||||
args.GetReturnValue().Set(args[0]);
|
||||
}
|
||||
|
||||
|
||||
// pass Buffer object to load prototype methods
|
||||
void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
|
||||
Environment* env = Environment::GetCurrent(args);
|
||||
@ -1238,6 +1323,7 @@ void Initialize(Local<Object> target,
|
||||
|
||||
env->SetMethod(target, "swap16", Swap16);
|
||||
env->SetMethod(target, "swap32", Swap32);
|
||||
env->SetMethod(target, "swap64", Swap64);
|
||||
|
||||
target->Set(env->context(),
|
||||
FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
|
||||
|
||||
@ -3,31 +3,28 @@
|
||||
require('../common');
|
||||
const assert = require('assert');
|
||||
|
||||
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4]);
|
||||
// Test buffers small enough to use the JS implementation
|
||||
const buf = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
|
||||
0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
|
||||
|
||||
assert.strictEqual(buf, buf.swap16());
|
||||
assert.deepStrictEqual(buf, Buffer.from([0x2, 0x1, 0x4, 0x3]));
|
||||
assert.deepStrictEqual(buf, Buffer.from([0x02, 0x01, 0x04, 0x03, 0x06, 0x05,
|
||||
0x08, 0x07, 0x0a, 0x09, 0x0c, 0x0b,
|
||||
0x0e, 0x0d, 0x10, 0x0f]));
|
||||
buf.swap16(); // restore
|
||||
|
||||
assert.strictEqual(buf, buf.swap32());
|
||||
assert.deepStrictEqual(buf, Buffer.from([0x3, 0x4, 0x1, 0x2]));
|
||||
assert.deepStrictEqual(buf, Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07,
|
||||
0x06, 0x05, 0x0c, 0x0b, 0x0a, 0x09,
|
||||
0x10, 0x0f, 0x0e, 0x0d]));
|
||||
buf.swap32(); // restore
|
||||
|
||||
const buf_array = [];
|
||||
for (var i = 1; i < 33; i++)
|
||||
buf_array.push(i);
|
||||
const buf2 = Buffer.from(buf_array);
|
||||
buf2.swap32();
|
||||
assert.deepStrictEqual(buf2,
|
||||
Buffer.from([0x04, 0x03, 0x02, 0x01, 0x08, 0x07, 0x06, 0x05, 0x0c,
|
||||
0x0b, 0x0a, 0x09, 0x10, 0x0f, 0x0e, 0x0d, 0x14, 0x13,
|
||||
0x12, 0x11, 0x18, 0x17, 0x16, 0x15, 0x1c, 0x1b, 0x1a,
|
||||
0x19, 0x20, 0x1f, 0x1e, 0x1d]));
|
||||
buf2.swap16();
|
||||
assert.deepStrictEqual(buf2,
|
||||
Buffer.from([0x03, 0x04, 0x01, 0x02, 0x07, 0x08, 0x05, 0x06, 0x0b,
|
||||
0x0c, 0x09, 0x0a, 0x0f, 0x10, 0x0d, 0x0e, 0x13, 0x14,
|
||||
0x11, 0x12, 0x17, 0x18, 0x15, 0x16, 0x1b, 0x1c, 0x19,
|
||||
0x1a, 0x1f, 0x20, 0x1d, 0x1e]));
|
||||
assert.strictEqual(buf, buf.swap64());
|
||||
assert.deepStrictEqual(buf, Buffer.from([0x08, 0x07, 0x06, 0x05, 0x04, 0x03,
|
||||
0x02, 0x01, 0x10, 0x0f, 0x0e, 0x0d,
|
||||
0x0c, 0x0b, 0x0a, 0x09]));
|
||||
|
||||
// Operates in-place
|
||||
const buf3 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7]);
|
||||
buf3.slice(1, 5).swap32();
|
||||
assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7]));
|
||||
@ -35,26 +32,107 @@ assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x5, 0x4, 0x3, 0x2, 0x6, 0x7]));
|
||||
buf3.slice(1, 5).swap16();
|
||||
assert.deepStrictEqual(buf3, Buffer.from([0x1, 0x4, 0x5, 0x2, 0x3, 0x6, 0x7]));
|
||||
|
||||
const buf3_64 = Buffer.from([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
||||
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
|
||||
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
||||
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10]);
|
||||
buf3_64.slice(2, 18).swap64();
|
||||
assert.deepStrictEqual(buf3_64, Buffer.from([0x01, 0x02, 0x0a, 0x09, 0x08, 0x07,
|
||||
0x06, 0x05, 0x04, 0x03, 0x02, 0x01,
|
||||
0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b,
|
||||
0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
|
||||
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
|
||||
0x0f, 0x10]));
|
||||
|
||||
// Force use of native code (Buffer size above threshold limit for js impl)
|
||||
const buf4 = Buffer.allocUnsafe(1024).fill([0x1, 0x2, 0x3, 0x4]);
|
||||
const buf5 = Buffer.allocUnsafe(1024).fill([0x2, 0x1, 0x4, 0x3]);
|
||||
const buf6 = Buffer.allocUnsafe(1024)
|
||||
.fill([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
|
||||
const buf7 = Buffer.allocUnsafe(1024)
|
||||
.fill([0x4, 0x3, 0x2, 0x1, 0x8, 0x7, 0x6, 0x5]);
|
||||
var buf4A = new Uint32Array(256).fill(0x04030201);
|
||||
var buf4 = Buffer.from(buf4A.buffer, buf4A.byteOffset);
|
||||
var buf5A = new Uint32Array(256).fill(0x03040102);
|
||||
var buf5 = Buffer.from(buf5A.buffer, buf5A.byteOffset);
|
||||
|
||||
buf4.swap16();
|
||||
assert.deepStrictEqual(buf4, buf5);
|
||||
|
||||
var buf6A = new Uint32Array(256).fill(0x04030201);
|
||||
var buf6 = Buffer.from(buf6A.buffer);
|
||||
var bu7A = new Uint32Array(256).fill(0x01020304);
|
||||
var buf7 = Buffer.from(bu7A.buffer, bu7A.byteOffset);
|
||||
|
||||
buf6.swap32();
|
||||
assert.deepStrictEqual(buf6, buf7);
|
||||
|
||||
var buf8A = new Uint8Array(256 * 8);
|
||||
var buf9A = new Uint8Array(256 * 8);
|
||||
for (let i = 0; i < buf8A.length; i++) {
|
||||
buf8A[i] = i % 8;
|
||||
buf9A[buf9A.length - i - 1] = i % 8;
|
||||
}
|
||||
var buf8 = Buffer.from(buf8A.buffer, buf8A.byteOffset);
|
||||
var buf9 = Buffer.from(buf9A.buffer, buf9A.byteOffset);
|
||||
|
||||
buf8.swap64();
|
||||
assert.deepStrictEqual(buf8, buf9);
|
||||
|
||||
// Test native code with buffers that are not memory-aligned
|
||||
var buf10A = new Uint8Array(256 * 8);
|
||||
var buf11A = new Uint8Array(256 * 8 - 2);
|
||||
for (let i = 0; i < buf10A.length; i++) {
|
||||
buf10A[i] = i % 2;
|
||||
}
|
||||
for (let i = 1; i < buf11A.length; i++) {
|
||||
buf11A[buf11A.length - i] = (i + 1) % 2;
|
||||
}
|
||||
var buf10 = Buffer.from(buf10A.buffer, buf10A.byteOffset);
|
||||
// 0|1 0|1 0|1...
|
||||
var buf11 = Buffer.from(buf11A.buffer, buf11A.byteOffset);
|
||||
// 0|0 1|0 1|0...
|
||||
|
||||
buf10.slice(1, buf10.length - 1).swap16();
|
||||
assert.deepStrictEqual(buf10.slice(0, buf11.length), buf11);
|
||||
|
||||
|
||||
var buf12A = new Uint8Array(256 * 8);
|
||||
var buf13A = new Uint8Array(256 * 8 - 4);
|
||||
for (let i = 0; i < buf12A.length; i++) {
|
||||
buf12A[i] = i % 4;
|
||||
}
|
||||
for (let i = 1; i < buf13A.length; i++) {
|
||||
buf13A[buf13A.length - i] = (i + 1) % 4;
|
||||
}
|
||||
var buf12 = Buffer.from(buf12A.buffer, buf12A.byteOffset);
|
||||
// 0|1 2 3 0|1 2 3...
|
||||
var buf13 = Buffer.from(buf13A.buffer, buf13A.byteOffset);
|
||||
// 0|0 3 2 1|0 3 2...
|
||||
|
||||
buf12.slice(1, buf12.length - 3).swap32();
|
||||
assert.deepStrictEqual(buf12.slice(0, buf13.length), buf13);
|
||||
|
||||
|
||||
var buf14A = new Uint8Array(256 * 8);
|
||||
var buf15A = new Uint8Array(256 * 8 - 8);
|
||||
for (let i = 0; i < buf14A.length; i++) {
|
||||
buf14A[i] = i % 8;
|
||||
}
|
||||
for (let i = 1; i < buf15A.length; i++) {
|
||||
buf15A[buf15A.length - i] = (i + 1) % 8;
|
||||
}
|
||||
var buf14 = Buffer.from(buf14A.buffer, buf14A.byteOffset);
|
||||
// 0|1 2 3 4 5 6 7 0|1 2 3 4...
|
||||
var buf15 = Buffer.from(buf15A.buffer, buf15A.byteOffset);
|
||||
// 0|0 7 6 5 4 3 2 1|0 7 6 5...
|
||||
|
||||
buf14.slice(1, buf14.length - 7).swap64();
|
||||
assert.deepStrictEqual(buf14.slice(0, buf15.length), buf15);
|
||||
|
||||
// Length assertions
|
||||
const re16 = /Buffer size must be a multiple of 16-bits/;
|
||||
const re32 = /Buffer size must be a multiple of 32-bits/;
|
||||
const re64 = /Buffer size must be a multiple of 64-bits/;
|
||||
|
||||
assert.throws(() => Buffer.from(buf3).swap16(), re16);
|
||||
assert.throws(() => Buffer.alloc(1025).swap16(), re16);
|
||||
assert.throws(() => Buffer.from(buf3).swap32(), re32);
|
||||
assert.throws(() => buf3.slice(1, 3).swap32(), re32);
|
||||
assert.throws(() => Buffer.alloc(1025).swap32(), re32);
|
||||
assert.throws(() => buf3.slice(1, 3).swap64(), re64);
|
||||
assert.throws(() => Buffer.alloc(1025).swap64(), re64);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user