diff --git a/benchmark/buffers/buffer-read.js b/benchmark/buffers/buffer-read.js index 19570a6b9241..9d5a19d6a5aa 100644 --- a/benchmark/buffers/buffer-read.js +++ b/benchmark/buffers/buffer-read.js @@ -1,5 +1,6 @@ 'use strict'; const common = require('../common.js'); +const assert = require('assert'); const { Buffer } = require('buffer'); const types = [ @@ -32,10 +33,12 @@ function main({ n, buffer, type }) { const fn = `read${type}`; buff.writeDoubleLE(0, 0); + let result; bench.start(); for (let i = 0; i !== n; i++) { - buff[fn](0); + result = buff[fn](0); } bench.end(n); + assert.notStrictEqual(result, undefined); } diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js index 3f99fe6d161a..d8160a0f6621 100644 --- a/lib/internal/buffer.js +++ b/lib/internal/buffer.js @@ -1,7 +1,8 @@ 'use strict'; const { - BigInt, + BigInt64Array, + BigUint64Array, Float32Array, Float64Array, MathFloor, @@ -50,6 +51,8 @@ const float32Array = new Float32Array(1); const uInt8Float32Array = new Uint8Array(float32Array.buffer); const float64Array = new Float64Array(1); const uInt8Float64Array = new Uint8Array(float64Array.buffer); +const bigInt64Array = new BigInt64Array(float64Array.buffer); +const bigUint64Array = new BigUint64Array(float64Array.buffer); // Check endianness. float32Array[0] = -1; // 0xBF800000 @@ -97,80 +100,52 @@ function boundsError(value, length, type) { } // Read integers. -function readBigUInt64LE(offset = 0) { +function readBigInt64Bytes(buf, offset, backwards) { validateNumber(offset, 'offset'); - const first = this[offset]; - const last = this[offset + 7]; + const first = buf[offset]; + const last = buf[offset + 7]; if (first === undefined || last === undefined) - boundsError(offset, this.length - 8); - - const lo = first + - this[++offset] * 2 ** 8 + - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 24; - - const hi = this[++offset] + - this[++offset] * 2 ** 8 + - this[++offset] * 2 ** 16 + - last * 2 ** 24; + boundsError(offset, buf.length - 8); + + if (backwards) { + uInt8Float64Array[7] = first; + uInt8Float64Array[6] = buf[++offset]; + uInt8Float64Array[5] = buf[++offset]; + uInt8Float64Array[4] = buf[++offset]; + uInt8Float64Array[3] = buf[++offset]; + uInt8Float64Array[2] = buf[++offset]; + uInt8Float64Array[1] = buf[++offset]; + uInt8Float64Array[0] = last; + } else { + uInt8Float64Array[0] = first; + uInt8Float64Array[1] = buf[++offset]; + uInt8Float64Array[2] = buf[++offset]; + uInt8Float64Array[3] = buf[++offset]; + uInt8Float64Array[4] = buf[++offset]; + uInt8Float64Array[5] = buf[++offset]; + uInt8Float64Array[6] = buf[++offset]; + uInt8Float64Array[7] = last; + } +} - return BigInt(lo) + (BigInt(hi) << 32n); +function readBigUInt64LE(offset = 0) { + readBigInt64Bytes(this, offset, bigEndian); + return bigUint64Array[0]; } function readBigUInt64BE(offset = 0) { - validateNumber(offset, 'offset'); - const first = this[offset]; - const last = this[offset + 7]; - if (first === undefined || last === undefined) - boundsError(offset, this.length - 8); - - const hi = first * 2 ** 24 + - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 8 + - this[++offset]; - - const lo = this[++offset] * 2 ** 24 + - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 8 + - last; - - return (BigInt(hi) << 32n) + BigInt(lo); + readBigInt64Bytes(this, offset, !bigEndian); + return bigUint64Array[0]; } function readBigInt64LE(offset = 0) { - validateNumber(offset, 'offset'); - const first = this[offset]; - const last = this[offset + 7]; - if (first === undefined || last === undefined) - boundsError(offset, this.length - 8); - - const val = this[offset + 4] + - this[offset + 5] * 2 ** 8 + - this[offset + 6] * 2 ** 16 + - (last << 24); // Overflow - return (BigInt(val) << 32n) + - BigInt(first + - this[++offset] * 2 ** 8 + - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 24); + readBigInt64Bytes(this, offset, bigEndian); + return bigInt64Array[0]; } function readBigInt64BE(offset = 0) { - validateNumber(offset, 'offset'); - const first = this[offset]; - const last = this[offset + 7]; - if (first === undefined || last === undefined) - boundsError(offset, this.length - 8); - - const val = (first << 24) + // Overflow - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 8 + - this[++offset]; - return (BigInt(val) << 32n) + - BigInt(this[++offset] * 2 ** 24 + - this[++offset] * 2 ** 16 + - this[++offset] * 2 ** 8 + - last); + readBigInt64Bytes(this, offset, !bigEndian); + return bigInt64Array[0]; } function readUIntLE(offset, byteLength) { @@ -583,66 +558,53 @@ function readDoubleForwards(offset = 0) { } // Write integers. -function writeBigU_Int64LE(buf, value, offset, min, max) { +function writeBigU_Int64(buf, value, offset, min, max, backwards) { checkInt(value, min, max, buf, offset, 7); - let lo = Number(value & 0xffffffffn); - buf[offset++] = lo; - lo = lo >> 8; - buf[offset++] = lo; - lo = lo >> 8; - buf[offset++] = lo; - lo = lo >> 8; - buf[offset++] = lo; - let hi = Number(value >> 32n & 0xffffffffn); - buf[offset++] = hi; - hi = hi >> 8; - buf[offset++] = hi; - hi = hi >> 8; - buf[offset++] = hi; - hi = hi >> 8; - buf[offset++] = hi; + // `& -1n` keeps the TypeError for non-BigInt values. + bigInt64Array[0] = value & -1n; + if (backwards) { + buf[offset++] = uInt8Float64Array[7]; + buf[offset++] = uInt8Float64Array[6]; + buf[offset++] = uInt8Float64Array[5]; + buf[offset++] = uInt8Float64Array[4]; + buf[offset++] = uInt8Float64Array[3]; + buf[offset++] = uInt8Float64Array[2]; + buf[offset++] = uInt8Float64Array[1]; + buf[offset++] = uInt8Float64Array[0]; + } else { + buf[offset++] = uInt8Float64Array[0]; + buf[offset++] = uInt8Float64Array[1]; + buf[offset++] = uInt8Float64Array[2]; + buf[offset++] = uInt8Float64Array[3]; + buf[offset++] = uInt8Float64Array[4]; + buf[offset++] = uInt8Float64Array[5]; + buf[offset++] = uInt8Float64Array[6]; + buf[offset++] = uInt8Float64Array[7]; + } return offset; } function writeBigUInt64LE(value, offset = 0) { - return writeBigU_Int64LE(this, value, offset, 0n, 0xffffffffffffffffn); -} - -function writeBigU_Int64BE(buf, value, offset, min, max) { - checkInt(value, min, max, buf, offset, 7); - - let lo = Number(value & 0xffffffffn); - buf[offset + 7] = lo; - lo = lo >> 8; - buf[offset + 6] = lo; - lo = lo >> 8; - buf[offset + 5] = lo; - lo = lo >> 8; - buf[offset + 4] = lo; - let hi = Number(value >> 32n & 0xffffffffn); - buf[offset + 3] = hi; - hi = hi >> 8; - buf[offset + 2] = hi; - hi = hi >> 8; - buf[offset + 1] = hi; - hi = hi >> 8; - buf[offset] = hi; - return offset + 8; + return writeBigU_Int64( + this, value, offset, 0n, 0xffffffffffffffffn, bigEndian); } function writeBigUInt64BE(value, offset = 0) { - return writeBigU_Int64BE(this, value, offset, 0n, 0xffffffffffffffffn); + return writeBigU_Int64( + this, value, offset, 0n, 0xffffffffffffffffn, !bigEndian); } function writeBigInt64LE(value, offset = 0) { - return writeBigU_Int64LE( - this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); + return writeBigU_Int64( + this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn, + bigEndian); } function writeBigInt64BE(value, offset = 0) { - return writeBigU_Int64BE( - this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn); + return writeBigU_Int64( + this, value, offset, -0x8000000000000000n, 0x7fffffffffffffffn, + !bigEndian); } function writeUIntLE(value, offset, byteLength) {