1. Bufferसिर्फ एक में देखने के लिए एक दृश्य हैArrayBuffer ।
ए Buffer, वास्तव में, एक है FastBuffer, जो extends(से विरासत में मिला) Uint8Array, जो कि वास्तविक स्मृति के एक ऑक्टेट-यूनिट व्यू ("आंशिक एक्सेसर") है, ए ArrayBuffer।
📜 नोड.जेएस 9.4.0/lib/buffer.js#L65-L73
class FastBuffer extends Uint8Array {
constructor(arg1, arg2, arg3) {
super(arg1, arg2, arg3);
}
}
FastBuffer.prototype.constructor = Buffer;
internalBuffer.FastBuffer = FastBuffer;
Buffer.prototype = FastBuffer.prototype;
2. एक ArrayBufferके आकार और उसके दृश्य का आकार भिन्न हो सकता है।
कारण # 1 Buffer.from(arrayBuffer[, byteOffset[, length]]):।
इसके साथ Buffer.from(arrayBuffer[, byteOffset[, length]]), आप Bufferइसके अंतर्निहित ArrayBufferऔर दृश्य की स्थिति और आकार को निर्दिष्ट करने के साथ बना सकते हैं ।
const test_buffer = Buffer.from(new ArrayBuffer(50), 40, 10);
console.info(test_buffer.buffer.byteLength); // 50; the size of the memory.
console.info(test_buffer.length); // 10; the size of the view.
कारण # 2: FastBufferस्मृति आवंटन।
यह आकार के आधार पर मेमोरी को दो अलग-अलग तरीकों से आवंटित करता है।
- यदि आकार किसी मेमोरी पूल के आकार के आधे से कम है और 0 नहीं है ("छोटा") : यह आवश्यक मेमोरी तैयार करने के लिए मेमोरी पूल का उपयोग करता है ।
- एल्स : यह एक समर्पित बनाता है
ArrayBufferजो वास्तव में आवश्यक मेमोरी को फिट करता है।
📜 नोड.जेएस 9.4.0/lib/buffer.js#L306-L320
function allocate(size) {
if (size <= 0) {
return new FastBuffer();
}
if (size < (Buffer.poolSize >>> 1)) {
if (size > (poolSize - poolOffset))
createPool();
var b = new FastBuffer(allocPool, poolOffset, size);
poolOffset += size;
alignPool();
return b;
} else {
return createUnsafeBuffer(size);
}
}
📜 नोड.जेएस 9.4.0/lib/buffer.js#L98-L100
function createUnsafeBuffer(size) {
return new FastBuffer(createUnsafeArrayBuffer(size));
}
" मेमोरी पूल " से आपका क्या मतलब है ?
एक मेमोरी पूल एस के लिए छोटे आकार के मेमोरी चंक्स रखने के लिए एक निश्चित आकार का पूर्व-आवंटित मेमोरी ब्लॉक है Buffer। इसके उपयोग से छोटे आकार की मेमोरी चंक्स को एक साथ कस कर रखा जाता है, इसलिए छोटे आकार के मेमोरी चंक्स के अलग-अलग प्रबंधन (आवंटन और डील्लोकेशन) के कारण होने वाले विखंडन को रोकता है।
इस स्थिति में, मेमोरी पूल ArrayBufferएस हैं जिनका आकार डिफ़ॉल्ट रूप से 8 KiB है, जो इसमें निर्दिष्ट है Buffer.poolSize। जब यह एक के लिए एक छोटे आकार की मेमोरी चंक प्रदान करना है Buffer, तो यह जांचता है कि क्या अंतिम मेमोरी पूल में इसे संभालने के लिए पर्याप्त मेमोरी है; यदि हां, तो यह एक बनाता है Bufferकि "विचारों" स्मृति पूल की दी गई आंशिक हिस्सा, अन्यथा, यह एक नई स्मृति पूल और इतने पर बनाता है।
आप ArrayBufferएक के अंतर्निहित का उपयोग कर सकते हैं Buffer। Bufferकी bufferसंपत्ति (यह है कि, से विरासत में मिली Uint8Array) यह रखती है। एक "छोटे" Buffer की bufferसंपत्ति एक है ArrayBufferकि पूरे स्मृति पूल प्रतिनिधित्व करता है। तो इस मामले में, ArrayBufferऔर Bufferआकार में भिन्न होता है।
const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);
// A `Buffer`'s `length` property holds the size, in octets, of the view.
// An `ArrayBuffer`'s `byteLength` property holds the size, in octets, of its data.
console.info(zero_sized_buffer.length); /// 0; the view's size.
console.info(zero_sized_buffer.buffer.byteLength); /// 0; the memory..'s size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.
console.info(small_buffer.length); /// 3; the view's size.
console.info(small_buffer.buffer.byteLength); /// 8192; the memory pool's size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.
console.info(big_buffer.length); /// 4096; the view's size.
console.info(big_buffer.buffer.byteLength); /// 4096; the memory's size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.
3. तो हम यह " विचारों " स्मृति निकालने की जरूरत है ।
एक ArrayBufferआकार में तय किया गया है, इसलिए हमें भाग की एक प्रति बनाकर इसे बाहर निकालने की आवश्यकता है। ऐसा करने के लिए, हम का उपयोग Bufferकी byteOffsetसंपत्ति और lengthसंपत्ति है, जो से लिए गए हैं Uint8Array, और विधि है, जो एक का एक हिस्सा की एक प्रतिलिपि बनाता । यहाँ -ing विधि @ZachB से प्रेरित थी ।ArrayBuffer.prototype.sliceArrayBufferslice()
const test_buffer = Buffer.from(new ArrayBuffer(10));
const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);
function extract_arraybuffer(buf)
{
// You may use the `byteLength` property instead of the `length` one.
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
}
// A copy -
const test_arraybuffer = extract_arraybuffer(test_buffer); // of the memory.
const zero_sized_arraybuffer = extract_arraybuffer(zero_sized_buffer); // of the... void.
const small_arraybuffer = extract_arraybuffer(small_buffer); // of the part of the memory.
const big_arraybuffer = extract_arraybuffer(big_buffer); // of the memory.
console.info(test_arraybuffer.byteLength); // 10
console.info(zero_sized_arraybuffer.byteLength); // 0
console.info(small_arraybuffer.byteLength); // 3
console.info(big_arraybuffer.byteLength); // 4096
4. प्रदर्शन में सुधार
यदि आप परिणाम को केवल पढ़ने के लिए उपयोग कर रहे हैं, या इनपुट Buffers की सामग्री को संशोधित करना ठीक है , तो आप अनावश्यक मेमोरी कॉपी से बच सकते हैं।
const test_buffer = Buffer.from(new ArrayBuffer(10));
const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);
function obtain_arraybuffer(buf)
{
if(buf.length === buf.buffer.byteLength)
{
return buf.buffer;
} // else:
// You may use the `byteLength` property instead of the `length` one.
return buf.subarray(0, buf.length);
}
// Its underlying `ArrayBuffer`.
const test_arraybuffer = obtain_arraybuffer(test_buffer);
// Just a zero-sized `ArrayBuffer`.
const zero_sized_arraybuffer = obtain_arraybuffer(zero_sized_buffer);
// A copy of the part of the memory.
const small_arraybuffer = obtain_arraybuffer(small_buffer);
// Its underlying `ArrayBuffer`.
const big_arraybuffer = obtain_arraybuffer(big_buffer);
console.info(test_arraybuffer.byteLength); // 10
console.info(zero_sized_arraybuffer.byteLength); // 0
console.info(small_arraybuffer.byteLength); // 3
console.info(big_arraybuffer.byteLength); // 4096