Reuse buffer after socket's done writing (if applicable)

Author: malthe

CHANGES.md

@@ -1,5 +1,8 @@
 In next release ...
 
+- Reduce buffer allocation and intelligently scale initial allocation when creating
+  a new buffer.
+
 - Both the `Query` object and client configuration now provide an optional `bigints`
   setting which decides whether to use bigints or the number type for the INT8
   data type. The setting is enabled by default.

src/buffer.ts

@@ -1,10 +1,9 @@
+const INITIAL_SIZE = 4096;
+
 export class ElasticBuffer {
     private offset = 0;
-    private buffer: Buffer;
-
-    constructor(size: number) {
-        this.buffer = Buffer.allocUnsafe(size);
-    }
+    private buffer?: Buffer;
+    private size = INITIAL_SIZE;
 
     clear() {
         this.offset = 0;
@@ -15,30 +14,42 @@ export class ElasticBuffer {
     }
 
     reserve(size: number) {
-        let length = this.buffer.length;
+        let length = this.buffer?.length || 0;
         const offset = this.offset;
         const available = length - offset;
 
-        if (available < size) {
-            while (available + length < size) length *= 2;
-            const buffer = Buffer.allocUnsafe(length * 2);
-            this.buffer.copy(buffer, 0, 0, offset);
+        if (available < size || !this.buffer) {
+            while (available + length < size) length = Math.max(this.size, length << 1);
+            const buffer = Buffer.allocUnsafe(length << 1);
+            if (this.buffer) {
+                this.buffer.copy(buffer, 0, 0, offset);
+            }
             this.buffer = buffer;
+            return buffer;
         }
+        return this.buffer;
     }
 
     getBuffer(size: number) {
         const offset = this.offset;
-        this.reserve(size);
+        const buffer = this.reserve(size);
         this.offset += size;
-        return this.buffer.subarray(offset, offset + size);
+        return buffer.subarray(offset, offset + size);
     }
 
     consume() {
-        const end = this.offset;
-        const buffer = Buffer.allocUnsafe(end);
-        this.buffer.copy(buffer, 0, 0, end);
+        const buffer = this.buffer?.subarray(0, this.offset);
+        if (buffer) {
+            this.size = Math.max(this.offset, INITIAL_SIZE) >> 1;
+        }
         this.offset = 0;
+        this.buffer = undefined;
         return buffer;
     }
+
+    offer(buffer: Buffer) {
+        if (!this.buffer) {
+            this.buffer = buffer;
+        }
+    }
 }

src/protocol.ts

@@ -659,7 +659,7 @@ export class Reader {
 }
 
 export class Writer {
-    private outgoing: ElasticBuffer = new ElasticBuffer(4096);
+    private outgoing: ElasticBuffer = new ElasticBuffer();
 
     constructor(private readonly encoding: BufferEncoding) { }
 
@@ -1085,7 +1085,10 @@ export class Writer {
     send(socket: Socket) {
         if (this.outgoing.empty) return;
         const buffer = this.outgoing.consume();
-        return socket.write(buffer);
+        if (buffer) {
+            return socket.write(buffer, () => this.outgoing.offer(buffer));
+        }
+        return true;
     }
 
     startup(settings: StartupConfiguration) {