@fluidframework/container-runtime 2.0.0-dev.4.1.0.148229 → 2.0.0-dev.4.3.0.157531

package/src/dataStores.ts

@@ -116,7 +116,7 @@ export class DataStores implements IDisposable {
 	constructor(
 		private readonly baseSnapshot: ISnapshotTree | undefined,
 		private readonly runtime: ContainerRuntime,
-		private readonly submitAttachFn: (attachContent: any) => void,
+		private readonly submitAttachFn: (attachContent: IAttachMessage) => void,
 		private readonly getCreateChildSummarizerNodeFn: (
 			id: string,
 			createParam: CreateChildSummarizerNodeParam,
@@ -399,22 +399,19 @@ export class DataStores implements IDisposable {
 	}
 	public readonly dispose = () => this.disposeOnce.value;
 
-	public resubmitDataStoreOp(content: any, localOpMetadata: unknown) {
-		const envelope = content as IEnvelope;
+	public resubmitDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x160 /* "There should be a store context for the op" */);
 		context.reSubmit(envelope.contents, localOpMetadata);
 	}
 
-	public rollbackDataStoreOp(content: any, localOpMetadata: unknown) {
-		const envelope = content as IEnvelope;
+	public rollbackDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
 		context.rollback(envelope.contents, localOpMetadata);
 	}
 
-	public async applyStashedOp(content: any): Promise<unknown> {
-		const envelope = content as IEnvelope;
+	public async applyStashedOp(envelope: IEnvelope): Promise<unknown> {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x161 /* "There should be a store context for the op" */);
 		return context.applyStashedOp(envelope.contents);

package/src/gc/garbageCollection.ts

@@ -465,6 +465,13 @@ export class GarbageCollector implements IGarbageCollector {
 		const fullGC =
 			options.fullGC ??
 			(this.configs.runFullGC === true || this.summaryStateTracker.doesSummaryStateNeedReset);
+
+		// Add the options that are used to run GC to the telemetry context.
+		telemetryContext?.setMultiple("fluid_GC", "Options", {
+			fullGC,
+			runSweep: options.runSweep,
+		});
+
 		const logger = options.logger
 			? ChildLogger.create(options.logger, undefined, {
 					all: { completedGCRuns: () => this.completedRuns },
@@ -489,12 +496,6 @@ export class GarbageCollector implements IGarbageCollector {
 			return undefined;
 		}
 
-		// Add the options that are used to run GC to the telemetry context.
-		telemetryContext?.setMultiple("fluid_GC", "Options", {
-			fullGC,
-			runSweep: options.runSweep,
-		});
-
 		return PerformanceEvent.timedExecAsync(
 			logger,
 			{ eventName: "GarbageCollection" },

package/src/gc/gcConfigs.ts

@@ -158,9 +158,7 @@ export function generateGCConfigs(
 
 	// If version upgrade is not enabled, fall back to the stable GC version.
 	const gcVersionInEffect =
-		mc.config.getBoolean(gcVersionUpgradeToV3Key) === false
-			? stableGCVersion
-			: currentGCVersion;
+		mc.config.getBoolean(gcVersionUpgradeToV3Key) === true ? currentGCVersion : stableGCVersion;
 
 	return {
 		gcEnabled,

package/src/gc/gcDefinitions.ts

@@ -23,7 +23,7 @@ import {
 export type GCVersion = number;
 
 /** The stable version of garbage collection in production. */
-export const stableGCVersion: GCVersion = 1;
+export const stableGCVersion: GCVersion = 2;
 /** The current version of garbage collection. */
 export const currentGCVersion: GCVersion = 3;
 

package/src/gc/gcHelpers.ts

@@ -169,7 +169,7 @@ export function concatGarbageCollectionStates(
 			) {
 				assert(
 					nodeData.unreferencedTimestampMs === combineNodeData.unreferencedTimestampMs,
-					"Two entries for the same GC node with different unreferenced timestamp",
+					0x5d7 /* Two entries for the same GC node with different unreferenced timestamp */,
 				);
 			}
 			combineNodeData = {
@@ -253,7 +253,7 @@ export async function getGCDataFromSnapshot(
 			continue;
 		}
 		const gcState = await readAndParseBlob<IGarbageCollectionState>(blobId);
-		assert(gcState !== undefined, "GC blob missing from snapshot");
+		assert(gcState !== undefined, 0x5d8 /* GC blob missing from snapshot */);
 		// Merge the GC state of this blob into the root GC state.
 		rootGCState = concatGarbageCollectionStates(rootGCState, gcState);
 	}
@@ -280,7 +280,7 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 			continue;
 		}
 
-		assert(id.startsWith("/"), "node id should always be an absolute route");
+		assert(id.startsWith("/"), 0x5d9 /* node id should always be an absolute route */);
 		const childId = id.split("/")[1];
 		let childGCNodeId = id.slice(childId.length + 1);
 		// GC node id always begins with "/". Handle the special case where a child's id in the parent's GC nodes is
@@ -294,7 +294,10 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 			childGCDetails = { gcData: { gcNodes: {} }, usedRoutes: [] };
 		}
 		// gcData should not undefined as its always at least initialized as  empty above.
-		assert(childGCDetails.gcData !== undefined, "Child GC data should have been initialized");
+		assert(
+			childGCDetails.gcData !== undefined,
+			0x5da /* Child GC data should have been initialized */,
+		);
 		childGCDetails.gcData.gcNodes[childGCNodeId] = [...new Set(outboundRoutes)];
 		childGCDetailsMap.set(childId, childGCDetails);
 	}
@@ -306,14 +309,14 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 	// Remove the node's self used route, if any, and generate the children used routes.
 	const usedRoutes = gcDetails.usedRoutes.filter((route) => route !== "" && route !== "/");
 	for (const route of usedRoutes) {
-		assert(route.startsWith("/"), "Used route should always be an absolute route");
+		assert(route.startsWith("/"), 0x5db /* Used route should always be an absolute route */);
 		const childId = route.split("/")[1];
 		const childUsedRoute = route.slice(childId.length + 1);
 
 		const childGCDetails = childGCDetailsMap.get(childId);
 		assert(
 			childGCDetails?.usedRoutes !== undefined,
-			"This should have be initialized when generate GC nodes above",
+			0x5dc /* This should have be initialized when generate GC nodes above */,
 		);
 
 		childGCDetails.usedRoutes.push(childUsedRoute);

package/src/id-compressor/README.md

@@ -0,0 +1,3 @@
+# ID Compressor
+
+An [IdCompressor](./idCompressor.ts) generates unique identifiers that may be efficiently compressed/decompressed and synchronized with other IdCompressors.

package/src/id-compressor/appendOnlySortedMap.ts

@@ -0,0 +1,427 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/* eslint-disable no-bitwise */
+
+import { assert } from "@fluidframework/common-utils";
+import { fail } from "./utils";
+
+/**
+ * A map in which entries are always added in key-sorted order.
+ * Supports appending and searching.
+ */
+export class AppendOnlySortedMap<K, V> {
+	protected readonly elements: (K | V)[] = [];
+
+	/**
+	 * @param comparator - a comparator for keys
+	 */
+	public constructor(protected readonly comparator: (a: K, b: K) => number) {}
+
+	/**
+	 * @returns the number of entries in this map
+	 */
+	public get size(): number {
+		return this.elements.length / 2;
+	}
+
+	/**
+	 * @returns the min key in the map.
+	 */
+	public minKey(): K | undefined {
+		return this.elements[0] as K | undefined;
+	}
+
+	/**
+	 * @returns the max key in the map.
+	 */
+	public maxKey(): K | undefined {
+		return this.elements[this.elements.length - 2] as K | undefined;
+	}
+
+	/**
+	 * @returns the min value in the map.
+	 */
+	public minValue(): V | undefined {
+		return this.elements[1] as V | undefined;
+	}
+
+	/**
+	 * @returns the min value in the map.
+	 */
+	public maxValue(): V | undefined {
+		return this.elements[this.elements.length - 1] as V | undefined;
+	}
+
+	/**
+	 * @returns the min key in the map.
+	 */
+	public first(): [K, V] | undefined {
+		const { elements } = this;
+		const { length } = elements;
+		if (length === 0) {
+			return undefined;
+		}
+		return [elements[0] as K, elements[1] as V];
+	}
+
+	/**
+	 * @returns the max key in the map.
+	 */
+	public last(): [K, V] | undefined {
+		const { elements } = this;
+		const { length } = elements;
+		if (length === 0) {
+			return undefined;
+		}
+		const lastKeyIndex = length - 2;
+		return [elements[lastKeyIndex] as K, elements[lastKeyIndex + 1] as V];
+	}
+
+	/**
+	 * Returns the element at the insertion index.
+	 */
+	public getAtIndex(index: number): [K, V] | undefined {
+		const realIndex = index * 2;
+		const { elements } = this;
+		if (realIndex < 0 || realIndex > elements.length - 1) {
+			return undefined;
+		}
+		return [elements[realIndex] as K, elements[realIndex + 1] as V];
+	}
+
+	/**
+	 * @returns an iterable of the entries in the map.
+	 */
+	public *entries(): IterableIterator<readonly [K, V]> {
+		const { elements } = this;
+		for (let i = 0; i < elements.length; i += 2) {
+			yield [elements[i] as K, elements[i + 1] as V];
+		}
+	}
+
+	/**
+	 * @returns an iterable of the keys in the map.
+	 */
+	public *keys(): IterableIterator<K> {
+		const { elements } = this;
+		for (let i = 0; i < elements.length; i += 2) {
+			yield elements[i] as K;
+		}
+	}
+
+	/**
+	 * @returns an iterable of the values in the map.
+	 */
+	public *values(): IterableIterator<V> {
+		const { elements } = this;
+		for (let i = 0; i < elements.length; i += 2) {
+			yield elements[i + 1] as V;
+		}
+	}
+
+	/**
+	 * @returns an iterable of the entries in the map, reversed.
+	 */
+	public *entriesReversed(): IterableIterator<readonly [K, V]> {
+		const { elements } = this;
+		for (let i = elements.length - 2; i >= 0; i -= 2) {
+			yield [elements[i] as K, elements[i + 1] as V];
+		}
+	}
+
+	/**
+	 * Adds a new key/value pair to the map. `key` must be \> to all keys in the map.
+	 * @param key - the key to add.
+	 * @param value - the value to add.
+	 */
+	public append(key: K, value: V): void {
+		const { elements } = this;
+		const { length } = elements;
+		if (length !== 0 && this.comparator(key, this.maxKey() as K) <= 0) {
+			fail("Inserted key must be > all others in the map.");
+		}
+		elements.push(key);
+		elements.push(value);
+	}
+
+	/**
+	 * @param key - the key to lookup.
+	 * @returns the value associated with `key` if such an entry exists, and undefined otherwise.
+	 */
+	public get(key: K): V | undefined {
+		const index = AppendOnlySortedMap.keyIndexOf(this.elements, key, this.comparator);
+		if (index < 0) {
+			return undefined;
+		}
+		return this.elements[index + 1] as V;
+	}
+
+	/**
+	 * @param key - the key to lookup.
+	 * @returns the entry associated with `key` if such an entry exists, the entry associated with the next lower key if such an entry
+	 * exists, and undefined otherwise.
+	 */
+	public getPairOrNextLower(key: K): readonly [K, V] | undefined {
+		return this.getPairOrNextLowerBy(key, this.comparator);
+	}
+
+	/**
+	 * @param key - the key to lookup.
+	 * @returns the entry associated with `key` if such an entry exists, the entry associated with the next higher key if such an entry
+	 * exists, and undefined otherwise.
+	 */
+	public getPairOrNextHigher(key: K): readonly [K, V] | undefined {
+		return this.getPairOrNextHigherBy(key, this.comparator);
+	}
+
+	/**
+	 * Compares two `AppendOnlySortedMap`s.
+	 */
+	public equals(
+		other: AppendOnlySortedMap<K, V>,
+		compareValues: (a: V, b: V) => boolean,
+	): boolean {
+		if (other === this) {
+			return true;
+		}
+
+		if (this.elements.length !== other.elements.length) {
+			return false;
+		}
+
+		for (let i = this.elements.length - 2; i >= 0; i -= 2) {
+			const keyThis = this.elements[i] as K;
+			const valueThis = this.elements[i + 1] as V;
+			const keyOther = other.elements[i] as K;
+			const valueOther = other.elements[i + 1] as V;
+			if (this.comparator(keyThis, keyOther) !== 0) {
+				return false;
+			}
+			if (!compareValues(valueThis, valueOther)) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Test-only expensive assertions to check the internal validity of the data structure.
+	 */
+	public assertValid(): void {
+		let prev: readonly [K, unknown] | undefined;
+		for (const kv of this.entries()) {
+			if (prev !== undefined) {
+				assert(
+					this.comparator(kv[0], prev[0]) > 0,
+					0x47f /* Keys in map must be sorted. */,
+				);
+			}
+			prev = kv;
+		}
+	}
+
+	/**
+	 * Queries a range of entries.
+	 * @param from - the key to start the range query at, inclusive.
+	 * @param to - the key to end the range query at, inclusive.
+	 * @returns the range of entries.
+	 */
+	public *getRange(from: K, to: K): IterableIterator<readonly [K, V]> {
+		const keyIndexFrom = this.getKeyIndexOfOrNextHigher(from, this.comparator);
+		if (keyIndexFrom === undefined) {
+			return;
+		}
+
+		const keyIndexTo = this.getKeyIndexOfOrNextLower(to, this.comparator);
+		if (keyIndexTo === undefined) {
+			return;
+		}
+
+		for (let i = keyIndexFrom; i <= keyIndexTo; i += 2) {
+			yield [this.elements[i] as K, this.elements[i + 1] as V];
+		}
+	}
+
+	protected getPairOrNextLowerBy<T>(
+		search: T,
+		comparator: (search: T, key: K, value: V) => number,
+	): readonly [K, V] | undefined {
+		const keyIndex = this.getKeyIndexOfOrNextLower(search, comparator);
+		if (keyIndex === undefined) {
+			return undefined;
+		}
+
+		return [this.elements[keyIndex] as K, this.elements[keyIndex + 1] as V];
+	}
+
+	private getKeyIndexOfOrNextLower<T>(
+		search: T,
+		comparator: (search: T, key: K, value: V) => number,
+	): number | undefined {
+		const { elements } = this;
+		if (elements.length === 0) {
+			return undefined;
+		}
+		let keyIndex = AppendOnlySortedMap.keyIndexOf(elements, search, comparator);
+		if (keyIndex < 0) {
+			keyIndex ^= AppendOnlySortedMap.failureXor;
+			if (keyIndex > 0) {
+				return keyIndex - 2;
+			}
+			return undefined;
+		}
+		return keyIndex;
+	}
+
+	protected getPairOrNextHigherBy<T>(
+		search: T,
+		comparator: (search: T, key: K, value: V) => number,
+	): readonly [K, V] | undefined {
+		const keyIndex = this.getKeyIndexOfOrNextHigher(search, comparator);
+		if (keyIndex === undefined) {
+			return undefined;
+		}
+
+		return [this.elements[keyIndex] as K, this.elements[keyIndex + 1] as V];
+	}
+
+	private getKeyIndexOfOrNextHigher<T>(
+		search: T,
+		comparator: (search: T, key: K, value: V) => number,
+	): number | undefined {
+		const { elements } = this;
+		const { length } = elements;
+		if (length === 0) {
+			return undefined;
+		}
+		let keyIndex = AppendOnlySortedMap.keyIndexOf(elements, search, comparator);
+		if (keyIndex < 0) {
+			keyIndex ^= AppendOnlySortedMap.failureXor;
+			if (keyIndex < length) {
+				return keyIndex;
+			}
+			return undefined;
+		}
+		return keyIndex;
+	}
+
+	/**
+	 * The value xor'd with the result index when a search fails.
+	 */
+	public static readonly failureXor = -1;
+
+	/**
+	 * Performs a binary search on the sorted array.
+	 * @returns the index of the key for `search`, or (if not present) the index it would have been inserted into xor'd
+	 * with `failureXor`. Note that negating is not an adequate solution as that could result in -0.
+	 */
+	public static keyIndexOf<T, K, V>(
+		elements: readonly (K | V)[],
+		search: T,
+		comparator: (search: T, key: K, value: V) => number,
+	): number {
+		// Low, high, and mid are addresses of [K,V] pairs and *not* key indices
+		let low = 0;
+		let high = elements.length / 2;
+		let mid = high >> 1;
+		while (low < high) {
+			const keyIndex = mid * 2;
+			const c = comparator(search, elements[keyIndex] as K, elements[keyIndex + 1] as V);
+			if (c > 0) {
+				low = mid + 1;
+			} else if (c < 0) {
+				high = mid;
+			} else if (c === 0) {
+				return keyIndex;
+			} else {
+				fail("Invalid comparator.");
+			}
+			mid = (low + high) >> 1;
+		}
+		return (mid * 2) ^ AppendOnlySortedMap.failureXor;
+	}
+}
+
+/**
+ * A map in which entries are always added in both key-sorted and value-sorted order.
+ * Supports appending and searching.
+ */
+export class AppendOnlyDoublySortedMap<K, V, S> extends AppendOnlySortedMap<K, V> {
+	public constructor(
+		keyComparator: (a: K, b: K) => number,
+		private readonly extractSearchValue: (value: V) => S,
+		private readonly valueComparator: (search: S, value: S) => number,
+	) {
+		super(keyComparator);
+	}
+
+	public override append(key: K, value: V): void {
+		if (
+			this.elements.length !== 0 &&
+			this.valueComparator(
+				this.extractSearchValue(value),
+				this.extractSearchValue(this.maxValue() as V),
+			) <= 0
+		) {
+			fail("Inserted value must be > all others in the map.");
+		}
+		super.append(key, value);
+	}
+
+	private readonly compareValues = (search: S, _: K, value: V): number => {
+		return this.valueComparator(search, this.extractSearchValue(value));
+	};
+
+	// /**
+	//  * @param value - the value to lookup.
+	//  * @returns the key associated with `value` if such an entry exists, and undefined otherwise.
+	//  */
+	// public getByValue(value: S): K | undefined {
+	//     const index = AppendOnlySortedMap.keyIndexOf(this.elements, value, this.compareValues);
+	//     return this.elements[index]?.[0];
+	// }
+
+	/**
+	 * @param searchValue - the search value to lookup.
+	 * @returns the entry who's value, when run through the extractor provided to the constructor, matches
+	 * `searchValue`. If no such entry exists, this method returns the next lower entry as determined by the value
+	 * comparator provided to the constructor. If no such entry exists, this method returns undefined.
+	 */
+	public getPairOrNextLowerByValue(searchValue: S): readonly [K, V] | undefined {
+		return this.getPairOrNextLowerBy(searchValue, this.compareValues);
+	}
+
+	/**
+	 * @param searchValue - the search value to lookup.
+	 * @returns the entry who's value, when run through the extractor provided to the constructor, matches `searchValue`. If no such entry
+	 * exists, this method returns the next higher entry as determined by the value comparator provided to the constructor. If no such entry
+	 * exists, this method returns undefined.
+	 */
+	public getPairOrNextHigherByValue(searchValue: S): readonly [K, V] | undefined {
+		return this.getPairOrNextHigherBy(searchValue, this.compareValues);
+	}
+
+	/**
+	 * Test-only expensive assertions to check the internal validity of the data structure.
+	 */
+	public override assertValid(): void {
+		super.assertValid();
+		let prev: readonly [unknown, V] | undefined;
+		for (const kv of this.entries()) {
+			if (prev !== undefined) {
+				assert(
+					this.valueComparator(
+						this.extractSearchValue(kv[1]),
+						this.extractSearchValue(prev[1]),
+					) > 0,
+					0x480 /* Values in map must be sorted. */,
+				);
+			}
+			prev = kv;
+		}
+	}
+}