Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 4 additions & 1 deletion benchmark/buffers/buffer-read.js
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
'use strict';
const common = require('../common.js');
const assert = require('assert');
const { Buffer } = require('buffer');

const types = [
Expand Down Expand Up @@ -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);
}
178 changes: 70 additions & 108 deletions lib/internal/buffer.js
Original file line number Diff line number Diff line change
@@ -1,7 +1,8 @@
'use strict';

const {
BigInt,
BigInt64Array,
BigUint64Array,
Float32Array,
Float64Array,
MathFloor,
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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) {
Expand Down Expand Up @@ -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) {
Expand Down
Loading