1berry/nodejs
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

v8: refactor struture of v8 module

Browse Source 
Use the more efficient module.exports = {} pattern,
restructure imports from bindings, requires.

PR-URL: https://github.com/nodejs/node/pull/12681
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
This commit is contained in:
James M Snell 2017-04-26 16:48:05 -07:00
parent bed4612c40
commit 1052383f7c
2 changed files with 62 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
benchmark/v8/get-stats.js
View File

@ -8,8 +8,7 @@ const bench = common.createBenchmark(main, {
'getHeapStatistics', 'getHeapStatistics',
'getHeapSpaceStatistics' 'getHeapSpaceStatistics'
], ],
n: [1e6], n: [1e6]
flags: ['--ignition --turbo', '']
}); });
function main(conf) { function main(conf) {

114
lib/v8.js
View File

@ -14,44 +14,50 @@
'use strict'; 'use strict';
const Buffer = require('buffer').Buffer; const { Buffer } = require('buffer');
const { Serializer, Deserializer } = process.binding('serdes');
const v8binding = process.binding('v8'); const { copy } = process.binding('buffer');
const serdesBinding = process.binding('serdes');
const bufferBinding = process.binding('buffer');
const { objectToString } = require('internal/util'); const { objectToString } = require('internal/util');
const { FastBuffer } = require('internal/buffer'); const { FastBuffer } = require('internal/buffer');
// Properties for heap statistics buffer extraction. const {
const heapStatisticsBuffer = cachedDataVersionTag,
new Float64Array(v8binding.heapStatisticsArrayBuffer); setFlagsFromString,
const kTotalHeapSizeIndex = v8binding.kTotalHeapSizeIndex; heapStatisticsArrayBuffer,
const kTotalHeapSizeExecutableIndex = v8binding.kTotalHeapSizeExecutableIndex; heapSpaceStatisticsArrayBuffer,
const kTotalPhysicalSizeIndex = v8binding.kTotalPhysicalSizeIndex; updateHeapStatisticsArrayBuffer,
const kTotalAvailableSize = v8binding.kTotalAvailableSize; updateHeapSpaceStatisticsArrayBuffer,
const kUsedHeapSizeIndex = v8binding.kUsedHeapSizeIndex;
const kHeapSizeLimitIndex = v8binding.kHeapSizeLimitIndex; // Properties for heap and heap space statistics buffer extraction.
const kDoesZapGarbageIndex = v8binding.kDoesZapGarbageIndex; kTotalHeapSizeIndex,
const kMallocedMemoryIndex = v8binding.kMallocedMemoryIndex; kTotalHeapSizeExecutableIndex,
const kPeakMallocedMemoryIndex = v8binding.kPeakMallocedMemoryIndex; kTotalPhysicalSizeIndex,
kTotalAvailableSize,
kUsedHeapSizeIndex,
kHeapSizeLimitIndex,
kDoesZapGarbageIndex,
kMallocedMemoryIndex,
kPeakMallocedMemoryIndex,
kHeapSpaces,
kHeapSpaceStatisticsPropertiesCount,
kSpaceSizeIndex,
kSpaceUsedSizeIndex,
kSpaceAvailableSizeIndex,
kPhysicalSpaceSizeIndex
} = process.binding('v8');
// Properties for heap space statistics buffer extraction.
const heapSpaceStatisticsBuffer =
new Float64Array(v8binding.heapSpaceStatisticsArrayBuffer);
const kHeapSpaces = v8binding.kHeapSpaces;
const kNumberOfHeapSpaces = kHeapSpaces.length; const kNumberOfHeapSpaces = kHeapSpaces.length;
const kHeapSpaceStatisticsPropertiesCount =
v8binding.kHeapSpaceStatisticsPropertiesCount;
const kSpaceSizeIndex = v8binding.kSpaceSizeIndex;
const kSpaceUsedSizeIndex = v8binding.kSpaceUsedSizeIndex;
const kSpaceAvailableSizeIndex = v8binding.kSpaceAvailableSizeIndex;
const kPhysicalSpaceSizeIndex = v8binding.kPhysicalSpaceSizeIndex;
exports.getHeapStatistics = function() { const heapStatisticsBuffer =
new Float64Array(heapStatisticsArrayBuffer);
const heapSpaceStatisticsBuffer =
new Float64Array(heapSpaceStatisticsArrayBuffer);
function getHeapStatistics() {
const buffer = heapStatisticsBuffer; const buffer = heapStatisticsBuffer;
v8binding.updateHeapStatisticsArrayBuffer(); updateHeapStatisticsArrayBuffer();
return { return {
'total_heap_size': buffer[kTotalHeapSizeIndex], 'total_heap_size': buffer[kTotalHeapSizeIndex],
@ -64,15 +70,12 @@ exports.getHeapStatistics = function() {
'peak_malloced_memory': buffer[kPeakMallocedMemoryIndex], 'peak_malloced_memory': buffer[kPeakMallocedMemoryIndex],
'does_zap_garbage': buffer[kDoesZapGarbageIndex] 'does_zap_garbage': buffer[kDoesZapGarbageIndex]
}; };
}; }
exports.cachedDataVersionTag = v8binding.cachedDataVersionTag; function getHeapSpaceStatistics() {
exports.setFlagsFromString = v8binding.setFlagsFromString;
exports.getHeapSpaceStatistics = function() {
const heapSpaceStatistics = new Array(kNumberOfHeapSpaces); const heapSpaceStatistics = new Array(kNumberOfHeapSpaces);
const buffer = heapSpaceStatisticsBuffer; const buffer = heapSpaceStatisticsBuffer;
v8binding.updateHeapSpaceStatisticsArrayBuffer(); updateHeapSpaceStatisticsArrayBuffer();
for (var i = 0; i < kNumberOfHeapSpaces; i++) { for (var i = 0; i < kNumberOfHeapSpaces; i++) {
const propertyOffset = i * kHeapSpaceStatisticsPropertiesCount; const propertyOffset = i * kHeapSpaceStatisticsPropertiesCount;
@ -86,17 +89,14 @@ exports.getHeapSpaceStatistics = function() {
} }
return heapSpaceStatistics; return heapSpaceStatistics;
}; }
/* V8 serialization API */ /* V8 serialization API */
const Serializer = exports.Serializer = serdesBinding.Serializer;
const Deserializer = exports.Deserializer = serdesBinding.Deserializer;
/* JS methods for the base objects */ /* JS methods for the base objects */
Serializer.prototype._getDataCloneError = Error; Serializer.prototype._getDataCloneError = Error;
Deserializer.prototype.readRawBytes = function(length) { Deserializer.prototype.readRawBytes = function readRawBytes(length) {
const offset = this._readRawBytes(length); const offset = this._readRawBytes(length);
// `this.buffer` can be a Buffer or a plain Uint8Array, so just calling // `this.buffer` can be a Buffer or a plain Uint8Array, so just calling
// `.slice()` doesn't work. // `.slice()` doesn't work.
@ -155,8 +155,6 @@ class DefaultSerializer extends Serializer {
} }
} }
exports.DefaultSerializer = DefaultSerializer;
class DefaultDeserializer extends Deserializer { class DefaultDeserializer extends Deserializer {
constructor(buffer) { constructor(buffer) {
super(buffer); super(buffer);
@ -176,27 +174,37 @@ class DefaultDeserializer extends Deserializer {
byteLength / BYTES_PER_ELEMENT); byteLength / BYTES_PER_ELEMENT);
} else { } else {
// Copy to an aligned buffer first. // Copy to an aligned buffer first.
const copy = Buffer.allocUnsafe(byteLength); const buffer_copy = Buffer.allocUnsafe(byteLength);
bufferBinding.copy(this.buffer, copy, 0, copy(this.buffer, buffer_copy, 0, byteOffset, byteOffset + byteLength);
byteOffset, byteOffset + byteLength); return new ctor(buffer_copy.buffer,
return new ctor(copy.buffer, buffer_copy.byteOffset,
copy.byteOffset,
byteLength / BYTES_PER_ELEMENT); byteLength / BYTES_PER_ELEMENT);
} }
} }
} }
exports.DefaultDeserializer = DefaultDeserializer; function serialize(value) {
exports.serialize = function serialize(value) {
const ser = new DefaultSerializer(); const ser = new DefaultSerializer();
ser.writeHeader(); ser.writeHeader();
ser.writeValue(value); ser.writeValue(value);
return ser.releaseBuffer(); return ser.releaseBuffer();
}; }
exports.deserialize = function deserialize(buffer) { function deserialize(buffer) {
const der = new DefaultDeserializer(buffer); const der = new DefaultDeserializer(buffer);
der.readHeader(); der.readHeader();
return der.readValue(); return der.readValue();
}
module.exports = exports = {
cachedDataVersionTag,
getHeapStatistics,
getHeapSpaceStatistics,
setFlagsFromString,
Serializer,
Deserializer,
DefaultSerializer,
DefaultDeserializer,
deserialize,
serialize
}; };