Improve slice compare performance

src/Coding.ts

@@ -50,9 +50,5 @@ export function decodeFixed32(buf: Buffer): number {
 
 export function getLengthPrefixedSlice(key: Slice): Slice {
   const internalKeySize = varint.decode(key.buffer)
-  const internalKeyBuffer = key.buffer.slice(
-    varint.decode.bytes,
-    varint.decode.bytes + internalKeySize
-  )
-  return new Slice(internalKeyBuffer)
+  return new Slice(key.buffer, varint.decode.bytes, internalKeySize)
 }

src/Format.ts

@@ -113,7 +113,7 @@ export class SequenceNumber {
 export function extractUserKey(ikey: Slice): Slice {
   // if ikey.size === 8, userkey is '' (empty)
   assert(ikey.size >= 8)
-  return new Slice(ikey.buffer.slice(0, ikey.size - 8))
+  return new Slice(ikey.buffer, 0, ikey.size - 8)
 }
 
 export class InternalKey extends Slice {

src/Slice.ts

@@ -6,7 +6,26 @@
  */
 
 export default class Slice {
-  constructor(value: unknown = Buffer.alloc(0)) {
+  static compare(a: Slice, b: Slice): 0 | -1 | 1 {
+    if (a === b) return 0
+
+    let x = a.length
+    let y = b.length
+
+    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+      if (a.srcBuffer[i + a.offset] !== b.srcBuffer[i + b.offset]) {
+        x = a.srcBuffer[i + a.offset]
+        y = b.srcBuffer[i + b.offset]
+        break
+      }
+    }
+
+    if (x < y) return -1
+    if (y < x) return 1
+    return 0
+  }
+
+  constructor(value: unknown = Buffer.alloc(0), offset = 0, length?: number) {
     if (value instanceof Slice) {
       this._buffer = value._buffer
     } else if (Buffer.isBuffer(value)) {
@@ -16,36 +35,59 @@ export default class Slice {
     } else {
       this._buffer = Buffer.from(JSON.stringify(value))
     }
+    this._offset = offset
+    this._length = length
   }
 
   private _buffer: Buffer
+  private _offset: number
+  private _length: number | void
+
+  get offset(): number {
+    return this._offset
+  }
 
   get buffer(): Buffer {
+    if (this.offset > 0) {
+      this._buffer = this._buffer.slice(this.offset)
+      this._offset = 0
+    }
+    if (this._length) {
+      this._buffer = this._buffer.slice(0, this._length)
+      delete this._length
+    }
     return this._buffer
   }
 
   set buffer(buf: Buffer) {
     this._buffer = buf
   }
 
+  get srcBuffer(): Buffer {
+    return this._buffer
+  }
+
   get length(): number {
-    return this._buffer.length
+    return this._length ? this._length : this._buffer.length - this.offset
   }
 
   get size(): number {
-    return this._buffer.length
+    return this.length
   }
 
   toString(encoding?: BufferEncoding): string {
-    return this._buffer.toString(encoding)
+    return this.buffer.toString(encoding)
   }
 
   clear(): void {
     this._buffer = Buffer.alloc(0)
+    this._offset = 0
+    delete this._length
   }
 
   compare(slice: Slice): number {
-    return this._buffer.compare(slice.buffer)
+    return Slice.compare(this, slice)
+    // return Buffer.compare(this.buffer, slice.buffer)
   }
 
   isEqual(slice: Slice): boolean {