perf: rework read-packed

Author: wavim

eslint.config.mjs

@@ -21,6 +21,14 @@ export default tslint.config(
 },
 tslint.configs.strictTypeChecked,
 tslint.configs.stylisticTypeChecked,
+{
+rules: {
+"@typescript-eslint/restrict-template-expressions": [
+"error",
+{ allowNumber: true },
+],
+},
+},
 
 stylistic.configs.recommended,
 prettier,

src/core/read-object/read-packed.ts

@@ -1,202 +1,149 @@
-import { readdir, readFile } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import { extname, join } from "node:path";
-import { promisify } from "node:util";
-import { inflate } from "node:zlib";
 import { Cache } from "../cache/cache";
+import { inflate } from "../utils/inflate";
 import { Pack, Packed } from "./pack";
 
+const ENOOBJ = new Error("could not get object info");
+
 export async function readPacked(
 repo: string,
 hash: string,
 
 cache: Cache,
 ): Promise<Buffer> {
 const packs = await cache.packs.memo(async () => {
-const packs: Pack[] = [];
 const packsPath = join(repo, ".git", "objects", "pack");
+const files = await readdir(packsPath);
 
-const packPaths = await readdir(packsPath);
-const idxPaths = packPaths.filter((path) => extname(path) === ".idx");
-
-for (const idxPath of idxPaths) {
-const idxBuffer = await readFile(join(packsPath, idxPath));
-const packPath = join(packsPath, idxPath.replace(".idx", ".pack"));
-
-packs.push(new Pack(idxBuffer, packPath));
-}
-
-return packs;
+const packs = files
+.filter((path) => extname(path) === ".pack")
+.map((pack) => Pack.build(packsPath, pack));
+return await Promise.all(packs);
 }, repo);
 
-let pack: Pack | undefined;
-let packed: Packed | undefined;
-
-for (pack of packs) {
-packed = await pack.queryRef(hash);
+for (const pack of packs) {
+const packed = await pack.readRef(hash);
 
-if (packed !== undefined) {
-break;
+if (packed) {
+return await read(pack, packed);
 }
 }
-
-if (pack === undefined || packed === undefined) {
-throw new Error("could not get object info");
-}
-
-return await parse(repo, pack, packed, cache);
+throw ENOOBJ;
 }
 
-interface Pointer {
-next: number;
+interface Offset {
+_: number;
 }
 
-async function parse(
-repo: string,
-pack: Pack,
-packed: Packed,
-
-cache: Cache,
-): Promise<Buffer> {
-const { offset, buffer } = packed;
-const pointer: Pointer = { next: 0 };
-
-const firstByte = buffer.readUint8(0);
-pointer.next++;
-
-const types = [
-"invalid",
-"commit",
-"tree",
-"blob",
-"tag",
-"reserved",
-"ofs-delta",
-"ref-delta",
-] as const;
-const type = types[(firstByte >> 4) & 0b0111];
-
-if (type === "invalid" || type === "reserved") {
-throw new Error("unsupported object type");
+async function read(pack: Pack, packed: Packed): Promise<Buffer> {
+const buffer = packed.buffer;
+const header = buffer.readUint8();
+const offset = { _: 1 } as Offset;
+
+// ref-delta is not supported, since pack is self-contained
+const type = ([null, "commit", "tree", "blob", "tag", null, "ofs-delta", null] as const)[
+(header >> 4) & 0b0111
+];
+if (type === null) {
+throw ENOOBJ;
 }
 
-const size = (firstByte & 0b1111) | (decodeSize(buffer, pointer) << 4);
+const size = (header & 0b1111) | (decLen(buffer, offset) << 4);
 
-if (type !== "ofs-delta" && type !== "ref-delta") {
-const objectHead = Buffer.from(`${type} ${size.toFixed()}\0`, "ascii");
-const objectBody = await promisify(inflate)(buffer.subarray(pointer.next));
+if (type !== "ofs-delta") {
+const head = Buffer.from(`${type} ${size}\0`, "ascii");
+const body = await inflate(buffer.subarray(offset._));
 
-return Buffer.concat([objectHead, objectBody]);
+return Buffer.concat([head, body]);
 }
 
-let base: Buffer | undefined;
-
-if (type === "ofs-delta") {
-const baseOffset = offset - decodeOffset(buffer, pointer);
-
-const packed = await pack.queryOfs(baseOffset);
-base = packed?.buffer;
+const baseOffset = packed.offset - decOfs(buffer, offset);
+const basePacked = await pack.readOfs(baseOffset);
 
-if (base === undefined) {
-throw new Error("could not get object info");
-}
-} else {
-const baseHash = buffer.toString("hex", pointer.next, pointer.next + 20);
-pointer.next += 20;
-
-base = await readPacked(repo, baseHash, cache);
+if (!basePacked) {
+throw ENOOBJ;
 }
+const base = await read(pack, basePacked);
 
-const delta = await promisify(inflate)(buffer.subarray(pointer.next));
-const deltaPointer = { next: 0 };
-
-decodeSize(delta, deltaPointer);
-const objectSize = decodeSize(delta, deltaPointer);
+const terminator = base.indexOf(0);
+const objectType = base.toString("ascii", 0, terminator).split(" ")[0];
 
-const instructs = delta.subarray(deltaPointer.next);
+const delta = await inflate(buffer.subarray(offset._));
+const deltaOffset = { _: 0 } as Offset;
 
-const headEnd = base.indexOf(0);
-const baseType = base.toString("ascii", 0, headEnd).split(" ")[0];
+decLen(delta, deltaOffset);
+const objectSize = decLen(delta, deltaOffset);
+const instructs = delta.subarray(deltaOffset._);
 
-const objectHead = Buffer.from(`${baseType} ${objectSize.toFixed()}\0`, "ascii");
-const objectBody = buildDelta(base.subarray(headEnd + 1), instructs);
+const objectHead = Buffer.from(`${objectType} ${objectSize}\0`, "ascii");
+const objectBody = buildDeltas(base.subarray(terminator + 1), instructs);
 
 return Buffer.concat([objectHead, objectBody]);
 }
 
-function buildDelta(base: Buffer, instructs: Buffer): Buffer {
+function buildDeltas(base: Buffer, instructs: Buffer): Buffer {
 const deltas = [];
 
 while (instructs.byteLength !== 0) {
 const instruction = instructs.readUint8(0);
 
 if ((instruction & 0x80) === 0) {
 const size = instruction & 0x7f;
-deltas.push(instructs.subarray(1, size + 1));
 
+deltas.push(instructs.subarray(1, size + 1));
 instructs = instructs.subarray(size + 1);
+
 continue;
 }
 
 const byteMask = instruction & 0x7f;
-const bytePointer: Pointer = { next: 1 };
+const byteOffset: Offset = { _: 1 };
 
-const offset = decodeInstruct(instructs, bytePointer, byteMask, "offset");
-const size = decodeInstruct(instructs, bytePointer, byteMask, "size");
+const ofs = decCpy(instructs, byteOffset, byteMask);
+const len = decCpy(instructs, byteOffset, byteMask >> 4);
 
-const delta = base.subarray(offset, offset + size);
-deltas.push(delta);
-
-instructs = instructs.subarray(bytePointer.next);
+deltas.push(base.subarray(ofs, ofs + len));
+instructs = instructs.subarray(byteOffset._);
 }
 
 return Buffer.concat(deltas);
 }
 
-function decodeSize(buffer: Buffer, pointer: Pointer): number {
-let byte = 0;
-let size = 0;
-let shift = 0;
+function decLen(buf: Buffer, ofs: Offset): number {
+let b = 0;
+let s = 0;
+let x = 0;
 
 do {
-byte = buffer.readUint8(pointer.next++);
-size |= (byte & 0x7f) << shift;
-shift += 7;
-} while (byte & 0x80);
+b = buf.readUint8(ofs._++);
+x |= (b & 0x7f) << s;
+s += 7;
+} while (b & 0x80);
 
-return size;
+return x;
 }
 
-function decodeOffset(buffer: Buffer, pointer: Pointer): number {
-let byte = buffer.readUint8(pointer.next++);
-let offset = byte & 0x7f;
+function decOfs(buf: Buffer, ofs: Offset): number {
+let b = buf.readUint8(ofs._++);
+let x = b & 0x7f;
 
-while (byte & 0x80) {
-byte = buffer.readUint8(pointer.next++);
-offset++;
-offset <<= 7;
-offset |= byte & 0x7f;
+while (b & 0x80) {
+b = buf.readUint8(ofs._++);
+x = ((x + 1) << 7) | (b & 0x7f);
 }
 
-return offset;
+return x;
 }
 
-function decodeInstruct(
-buffer: Buffer,
-pointer: Pointer,
-
-mask: number,
-type: "offset" | "size",
-): number {
-let value = 0;
-let shift = 0;
-
-const fm = type === "offset" ? 0 : 4;
-const to = type === "offset" ? 4 : 7;
+function decCpy(buf: Buffer, ofs: Offset, mask: number): number {
+let s = 0;
+let x = 0;
 
-for (let i = fm; i < to; i++) {
-value |= (mask >> i) & 1 ? buffer.readUint8(pointer.next++) << shift : 0;
-shift += 8;
+for (let i = 0; i < 4; i++) {
+x |= (mask >> i) & 1 && buf.readUint8(ofs._++) << s;
+s += 8;
 }
 
-return value;
+return x;
 }