perf: graduate asset-server binary search experiment to 100%

The improved iterative binary search implementation has been graduated from a 50% experiment to the default implementation. This provides better performance for asset manifest lookups by replacing the recursive binary search with an iterative approach.

Changes:
- Replace experimental logic in worker.ts with direct usage of improved implementation
- Update assets-manifest.ts to use iterative binary search algorithm
- Remove experimental files (assets-manifest.2.ts and its test file)
- Update tests to work with new implementation signature
- Add changeset documenting the performance improvement

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: GregBrimble

.changeset/graduate-asset-server-experiment.md

@@ -0,0 +1,7 @@
+---
+"@cloudflare/workers-shared": patch
+---
+
+perf: graduate asset-server binary search experiment to 100%
+
+The improved iterative binary search implementation has been graduated from a 50% experiment to the default implementation. This provides better performance for asset manifest lookups by replacing the recursive binary search with an iterative approach.

packages/workers-shared/asset-worker/src/assets-manifest.2.ts

@@ -1,24 +1,22 @@
 import {
+	CONTENT_HASH_OFFSET,
 	CONTENT_HASH_SIZE,
 	ENTRY_SIZE,
 	HEADER_SIZE,
 	PATH_HASH_SIZE,
 } from "../../utils/constants";
 
 export class AssetsManifest {
-	private data: ArrayBuffer;
+	private data: Uint8Array;
 
 	constructor(data: ArrayBuffer) {
-		this.data = data;
+		this.data = new Uint8Array(data);
 	}
 
 	async get(pathname: string) {
 		const pathHash = await hashPath(pathname);
-		const entry = binarySearch(
-			new Uint8Array(this.data, HEADER_SIZE),
-			pathHash
-		);
-		return entry ? contentHashToKey(entry) : null;
+		const entry = binarySearch(this.data, pathHash);
+		return entry ? Uint8ToHexString(entry) : null;
 	}
 }
 
@@ -32,41 +30,103 @@ export const hashPath = async (path: string) => {
 	return new Uint8Array(hashBuffer, 0, PATH_HASH_SIZE);
 };
 
+/**
+ * Search for an entry with the given hash path.
+ *
+ * @param manifest the manifest bytes
+ * @param pathHash the path hash to find in the manifest
+ * @returns The content hash when the entry is found and `false` otherwise
+ */
 export const binarySearch = (
-	arr: Uint8Array,
-	searchValue: Uint8Array
+	manifest: Uint8Array,
+	pathHash: Uint8Array
 ): Uint8Array | false => {
-	if (arr.byteLength === 0) {
-		return false;
-	}
-	const offset =
-		arr.byteOffset + ((arr.byteLength / ENTRY_SIZE) >> 1) * ENTRY_SIZE;
-	const current = new Uint8Array(arr.buffer, offset, PATH_HASH_SIZE);
-	if (current.byteLength !== searchValue.byteLength) {
+	if (pathHash.byteLength !== PATH_HASH_SIZE) {
 		throw new TypeError(
-			"Search value and current value are of different lengths"
+			`Search value should have a length of ${PATH_HASH_SIZE}`
 		);
 	}
-	const cmp = compare(searchValue, current);
-	if (cmp < 0) {
-		const nextOffset = arr.byteOffset;
-		const nextLength = offset - arr.byteOffset;
-		return binarySearch(
-			new Uint8Array(arr.buffer, nextOffset, nextLength),
-			searchValue
-		);
-	} else if (cmp > 0) {
-		const nextOffset = offset + ENTRY_SIZE;
-		const nextLength = arr.buffer.byteLength - offset - ENTRY_SIZE;
-		return binarySearch(
-			new Uint8Array(arr.buffer, nextOffset, nextLength),
-			searchValue
+
+	const numberOfEntries = (manifest.byteLength - HEADER_SIZE) / ENTRY_SIZE;
+
+	if (numberOfEntries === 0) {
+		return false;
+	}
+
+	let lowIndex = 0;
+	let highIndex = numberOfEntries - 1;
+
+	while (lowIndex <= highIndex) {
+		const middleIndex = (lowIndex + highIndex) >> 1;
+
+		const cmp = comparePathHashWithEntry(pathHash, manifest, middleIndex);
+
+		if (cmp < 0) {
+			highIndex = middleIndex - 1;
+			continue;
+		}
+
+		if (cmp > 0) {
+			lowIndex = middleIndex + 1;
+			continue;
+		}
+
+		return new Uint8Array(
+			manifest.buffer,
+			HEADER_SIZE + middleIndex * ENTRY_SIZE + CONTENT_HASH_OFFSET,
+			CONTENT_HASH_SIZE
 		);
-	} else {
-		return new Uint8Array(arr.buffer, offset, ENTRY_SIZE);
 	}
+
+	return false;
+};
+
+/**
+ * Compares a search value with an entry in the manifest
+ *
+ * @param searchValue a `Uint8Array` of size `PATH_HASH_SIZE`
+ * @param manifest the manifest bytes
+ * @param entryIndex the index in the manifest of the entry to compare
+ */
+function comparePathHashWithEntry(
+	searchValue: Uint8Array,
+	manifest: Uint8Array,
+	entryIndex: number
+) {
+	let entryOffset = HEADER_SIZE + entryIndex * ENTRY_SIZE;
+	for (let offset = 0; offset < PATH_HASH_SIZE; offset++, entryOffset++) {
+		// We know that both values could not be undefined
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const s = searchValue[offset]!;
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const e = manifest[entryOffset]!;
+		if (s < e) {
+			return -1;
+		}
+		if (s > e) {
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+/**
+ * Converts an Uint8Array to an hex string
+ *
+ * @param array The content hash
+ * @returns padded hex string
+ */
+const Uint8ToHexString = (array: Uint8Array) => {
+	return [...array].map((b) => b.toString(16).padStart(2, "0")).join("");
 };
 
+/**
+ * Compare two Uint8Array values
+ * @param a First array
+ * @param b Second array
+ * @returns -1 if a < b, 1 if a > b, 0 if equal
+ */
 export const compare = (a: Uint8Array, b: Uint8Array) => {
 	if (a.byteLength < b.byteLength) {
 		return -1;
@@ -86,12 +146,4 @@ export const compare = (a: Uint8Array, b: Uint8Array) => {
 	}
 
 	return 0;
-};
-
-const contentHashToKey = (buffer: Uint8Array) => {
-	const contentHash = buffer.slice(
-		PATH_HASH_SIZE,
-		PATH_HASH_SIZE + CONTENT_HASH_SIZE
-	);
-	return [...contentHash].map((b) => b.toString(16).padStart(2, "0")).join("");
-};
+};

packages/workers-shared/asset-worker/src/assets-manifest.ts

@@ -4,7 +4,6 @@ import { setupSentry } from "../../utils/sentry";
 import { mockJaegerBinding } from "../../utils/tracing";
 import { Analytics } from "./analytics";
 import { AssetsManifest } from "./assets-manifest";
-import { AssetsManifest as AssetsManifest2 } from "./assets-manifest.2";
 import { normalizeConfiguration } from "./configuration";
 import { ExperimentAnalytics } from "./experiment-analytics";
 import { canFetch, handleRequest } from "./handler";
@@ -232,12 +231,6 @@ export default class<TEnv extends Env = Env> extends WorkerEntrypoint<TEnv> {
 		pathname: string,
 		_request?: Request
 	): Promise<string | null> {
-		const BINARY_SEARCH_EXPERIMENT_SAMPLE_RATE = 0.5;
-		const binarySearchVersion =
-			Math.random() < BINARY_SEARCH_EXPERIMENT_SAMPLE_RATE
-				? "current"
-				: "perfTest";
-
 		const analytics = new ExperimentAnalytics(this.env.EXPERIMENT_ANALYTICS);
 		const performance = new PerformanceTimer(this.env.UNSAFE_PERFORMANCE);
 		const jaeger = this.env.JAEGER ?? mockJaegerBinding();
@@ -250,31 +243,13 @@ export default class<TEnv extends Env = Env> extends WorkerEntrypoint<TEnv> {
 				analytics.setData({
 					accountId: this.env.CONFIG.account_id,
 					experimentName: "manifest-read-timing",
-					binarySearchVersion,
 				});
 			}
 
 			const startTimeMs = performance.now();
 			try {
-				let eTag: string | null;
-
-				if (binarySearchVersion === "perfTest") {
-					try {
-						const assetsManifest = new AssetsManifest2(
-							this.env.ASSETS_MANIFEST
-						);
-						eTag = await assetsManifest.get(pathname);
-					} catch {
-						// Fallback to the "current" impl if the new one throws.
-						// We use "current-fallback" to surface errors in the analytics data
-						analytics.setData({ binarySearchVersion: "current-fallback" });
-						const assetsManifest = new AssetsManifest(this.env.ASSETS_MANIFEST);
-						eTag = await assetsManifest.get(pathname);
-					}
-				} else {
-					const assetsManifest = new AssetsManifest(this.env.ASSETS_MANIFEST);
-					eTag = await assetsManifest.get(pathname);
-				}
+				const assetsManifest = new AssetsManifest(this.env.ASSETS_MANIFEST);
+				const eTag = await assetsManifest.get(pathname);
 
 				span.setTags({
 					path: pathname,