Node.js源碼解析-Buffer的8k池實現

Node.js源碼解析-Buffer的8k池實現

歡迎來個人博客閱讀：《Node.js源碼解析-Buffer的8k池實現》

在 Node.js 中，對於大文件通常是以 Buffer 形式存儲，相比於字符串，Buffer 能夠免去 decode / encode 過程，節省 CPU 成本

說到 Buffer 就不得不提到 Buffer 的 8k 池，那麼，下面就讓咱們來看看 8k 池是如何實現的吧

8k池實現

在 Node.js v8.4.0 中，能夠經過如下方法來獲取一個 Buffer 實例：

• new Buffer() ( 不推薦 )

• Buffer.from()

• Buffer.alloc()

• Buffer.allocUnsafe()

• Buffer.allocUnsafeSlow()

從命名上來看，Buffer.allocUnsafe() 和 Buffer.allocUnsafeSlow() 都是不安全的，有泄漏內存中敏感信息的危險

unsafe 的問題放到後面說，先看看如何獲取一個 Buffer 實例

從圖中能夠看出，只有 allocate() 和 fromString() 兩個函數直接與8k池相關

// lib/buffer.js

function allocate(size) {
  if (size <= 0) {
    return new FastBuffer();
  }
  if (size < (Buffer.poolSize >>> 1)) { // < 4k
    if (size > (poolSize - poolOffset)) // 大於剩餘容量
      createPool();
    var b = new FastBuffer(allocPool, poolOffset, size);
    poolOffset += size;
    alignPool();
    return b;
  } else { // > 4k
    return createUnsafeBuffer(size);
  }
}

function fromString(string, encoding) {
  // ...
  if (length >= (Buffer.poolSize >>> 1)) // > 4k
    return binding.createFromString(string, encoding);

  if (length > (poolSize - poolOffset)) // 大於剩餘容量
    createPool();
  var b = new FastBuffer(allocPool, poolOffset, length);
  const actual = b.write(string, encoding);
  if (actual !== length) { // byteLength() 可能會估計錯誤，儘管可能性很小
    b = new FastBuffer(allocPool, poolOffset, actual);
  }
  poolOffset += actual;
  alignPool();
  return b;
}

allocate() 和 fromString() 都是分爲大於 4k 和小於 4k 兩種狀況來處理

小於 4k 時，先檢查8k池的剩餘容量，若是大於剩餘容量則直接建立一個新的8k池，而後修正 poolOffset，最後調用 alignPool()

// lib/buffer.js

Buffer.poolSize = 8 * 1024;
var poolSize, poolOffset, allocPool;

function createUnsafeArrayBuffer(size) {
  // ...
  return new ArrayBuffer(size);
  // ...
}

function createPool() {
  poolSize = Buffer.poolSize; // 8k
  allocPool = createUnsafeArrayBuffer(poolSize);
  poolOffset = 0;
}
createPool();

function alignPool() {
  if (poolOffset & 0x7) { // 進行校準，只能爲 8 的倍數
    poolOffset |= 0x7; // xxx111
    poolOffset++; // xx(x+1)000
  }
}

經過調用 alignPool() 來校準 poolOffset，poolOffset 只能爲 8 的倍數，換句話說，每次至少使用 8 個字節內存

8k池容量不夠時，調用 createPool()，建立一個新的8k池

createPool() 內部調用 createUnsafeArrayBuffer() 來獲取一個對應大小的 ArrayBuffer 實例

關於 ArrayBuffer，這裏引用 MDN 的介紹：

The ArrayBuffer object is used to represent a generic, fixed-length raw binary data buffer

由於 ArrayBuffer 是 raw binary data，因此它是不安全的，存在泄漏內存中敏感信息的危險

Why Unsafe ?

從圖中咱們知道，一共有 4 種方法來得到一個 Buffer 實例，它們之中，有的是 unsafe 的，有的不是

new Buffer() 依賴 Buffer.from() 和 Buffer.alloc() 不算一種

下面讓咱們來看看爲何有的是 unsafe 的

// lib/buffer.js

// safe
Buffer.from = function(value, encodingOrOffset, length) {
  if (typeof value === 'string')
    return fromString(value, encodingOrOffset); // safe

  if (isAnyArrayBuffer(value))
    return fromArrayBuffer(value, encodingOrOffset, length); // safe

  var b = fromObject(value); // safe
  // ...
};

function fromString(string, encoding) {
  // ...
  var b = new FastBuffer(allocPool, poolOffset, length);
  const actual = b.write(string, encoding);
  // ...
}

function fromArrayBuffer(obj, byteOffset, length) {
  // ...
  return new FastBuffer(obj, byteOffset, length);
}

function fromObject(obj) {
  if (isUint8Array(obj)) {
    const b = allocate(obj.length);
    // ...
    binding.copy(obj, b, 0, 0, obj.length);
  }

  if (obj != null) {
    // ...
      return fromArrayLike(obj);
    // ...
  }
}

function fromArrayLike(obj) {
  // ...
  const b = allocate(length);
  for (var i = 0; i < length; i++)
    b[i] = obj[i];
  return b;
}

// unsafe
Buffer.allocUnsafe = function(size) {
  return allocate(size);
};

// unsafe
Buffer.allocUnsafeSlow = function(size) {
  return createUnsafeBuffer(size);
};

function createUnsafeBuffer(size) {
  return new FastBuffer(createUnsafeArrayBuffer(size));
}

// safe
Buffer.alloc = function(size, fill, encoding) {
  assertSize(size);
  if (size > 0 && fill !== undefined) {
    // ...
    return createUnsafeBuffer(size).fill(fill, encoding); 
  }
  return new FastBuffer(size);
};

能夠看出:

• Buffer.from() 和 Buffer.alloc(): 取到原始 buffer 後，對原始數據進行了替換，因此它們是 safe 的

• Buffer.allocUnsafe() 和 Buffer.allocUnsafeSlow(): 直接使用原始 buffer，因此它們是 unsafe 的

End

• new Buffer(): 依賴 Buffer.from() 和 Buffer.alloc()

• Buffer.from()

  • ArrayBuffer: 直接使用 ArrayBuffer 建立 FastBuffer

  • String: 小於 4k 使用8k池，大於 4k 調用 binding.createFromString()

  • Object: 小於 4k 使用8k池，大於 4k 調用 createUnsafeBuffer()

• Buffer.alloc(): 須要 fill buffer，用給定字符填充，不然用 0 填充

• Buffer.allocUnsafe(): 小於 4k 使用8k池，大於 4k 調用 createUnsafeBuffer()

• Buffer.allocUnsafeSlow(): 調用 createUnsafeBuffer()

參考：

• https://github.com/nodejs/node/blob/master/lib/buffer.js