@fluidframework/tree 2.22.0 → 2.23.0-323641

package/src/shared-tree-core/editManager.ts

@@ -472,7 +472,7 @@ export class EditManager<
 		// `EditManager` would have to be amended in one of two ways:
 		// A) Changes made by the local session should be represented by a branch in `EditManager.branches`.
 		// B) The contents of such a branch should be computed on demand based on the trunk.
-		// Note that option (A) would be a simple change to `addSequencedChange` whereas (B) would likely require
+		// Note that option (A) would be a simple change to `addSequencedChanges` whereas (B) would likely require
 		// rebasing trunk changes over the inverse of trunk changes.
 		assert(
 			this.localBranch.getHead() === this.trunk.getHead(),
@@ -646,24 +646,45 @@ export class EditManager<
 		return Math.max(max, localPath.length);
 	}
 
-	public addSequencedChange(
-		newCommit: Commit<TChangeset>,
+	/* eslint-disable jsdoc/check-indentation */
+	/**
+	 * Add a bunch of sequenced changes. A bunch is a group of sequenced commits that have the following properties:
+	 * - They are not interleaved with messages from other DDSes in the container.
+	 * - They are all part of the same batch, which entails:
+	 *   - They are contiguous in sequencing order.
+	 *   - They are all from the same client.
+	 *   - They are all based on the same reference sequence number.
+	 *   - They are not interleaved with messages from other clients.
+	 */
+	/* eslint-enable jsdoc/check-indentation */
+	public addSequencedChanges(
+		newCommits: readonly GraphCommit<TChangeset>[],
+		sessionId: SessionId,
 		sequenceNumber: SeqNumber,
 		referenceSequenceNumber: SeqNumber,
 	): void {
+		assert(newCommits.length > 0, "Expected at least one sequenced change");
 		assert(
 			sequenceNumber > this.minimumSequenceNumber,
 			0x713 /* Expected change sequence number to exceed the last known minimum sequence number */,
 		);
-
 		assert(
 			sequenceNumber >= // This is ">=", not ">" because changes in the same batch will have the same sequence number
 				(this.sequenceMap.maxKey()?.sequenceNumber ?? minimumPossibleSequenceNumber),
 			0xa64 /* Attempted to sequence change with an outdated sequence number */,
 		);
 
+		// Returns the sequence id for the next commit to be processed in the bunch. Since all the commits have the
+		// same sequence number, only the index in the batch needs to be incremented.
+		const getNextSequenceId = (sequenceId: SequenceId): SequenceId => {
+			return {
+				sequenceNumber: sequenceId.sequenceNumber,
+				indexInBatch: (sequenceId.indexInBatch ?? 0) + 1,
+			};
+		};
 		const commitsSequenceNumber = this.getBatch(sequenceNumber);
-		const sequenceId: SequenceId =
+		// The sequence id for the next commit to be processed in the bunch.
+		let nextSequenceId =
 			commitsSequenceNumber.length === 0
 				? {
 						sequenceNumber,
@@ -673,49 +694,65 @@ export class EditManager<
 						indexInBatch: commitsSequenceNumber.length,
 					};
 
-		if (newCommit.sessionId === this.localSessionId) {
-			return this.fastForwardNextLocalCommit(sequenceId);
+		// Local changes, i.e., changes from this client are applied by fast forwarding the local branch commit onto
+		// the trunk.
+		if (sessionId === this.localSessionId) {
+			for (const _ of newCommits) {
+				this.fastForwardNextLocalCommit(nextSequenceId);
+				nextSequenceId = getNextSequenceId(nextSequenceId);
+			}
+			return;
 		}
 
-		// Get the revision that the remote change is based on
-		const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
-		// Rebase that branch over the part of the trunk up to the base revision
-		// This will be a no-op if the sending client has not advanced since the last time we received an edit from it
-		const peerLocalBranch = getOrCreate(
-			this.peerLocalBranches,
-			newCommit.sessionId,
-			() => new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
-		);
-		peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
-
-		if (peerLocalBranch.getHead() === this.trunk.getHead()) {
-			// If the branch is fully caught up and empty after being rebased, then push to the trunk directly
-			this.pushCommitToTrunk(sequenceId, newCommit);
-			peerLocalBranch.setHead(this.trunk.getHead());
-		} else {
-			// Otherwise, rebase the change over the trunk and append it, and append the original change to the peer branch.
-			const { duration, output: newChangeFullyRebased } = measure(() =>
-				rebaseChange(
-					this.changeFamily.rebaser,
-					newCommit,
-					peerLocalBranch.getHead(),
-					this.trunk.getHead(),
-					this.mintRevisionTag,
-				),
+		// Remote changes, i.e., changes from remote clients are applied in three steps.
+		for (const newCommit of newCommits) {
+			// Step 1 - Recreate the peer remote client's local environment.
+			// Get the revision that the remote change is based on
+			const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
+			// Rebase that peer local branch over the part of the trunk up to the base revision
+			// This will be a no-op if the sending client has not advanced since the last time we received an edit from it
+			const peerLocalBranch = getOrCreate(
+				this.peerLocalBranches,
+				sessionId,
+				() =>
+					new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
 			);
+			peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
 
-			this.telemetryEventBatcher?.accumulateAndLog({
-				duration,
-				...newChangeFullyRebased.telemetryProperties,
-			});
+			// Step 2 - Append the change to the peer branch. Rebase the change to the tip of the trunk.
+			if (peerLocalBranch.getHead() === this.trunk.getHead()) {
+				// If the branch is fully caught up and empty after being rebased, then push to the trunk directly
+				this.pushCommitToTrunk(nextSequenceId, { ...newCommit, sessionId });
+				peerLocalBranch.setHead(this.trunk.getHead());
+			} else {
+				// Otherwise, rebase the change over the trunk and append it, and append the original change to the peer branch.
+				const { duration, output: newChangeFullyRebased } = measure(() =>
+					rebaseChange(
+						this.changeFamily.rebaser,
+						newCommit,
+						peerLocalBranch.getHead(),
+						this.trunk.getHead(),
+						this.mintRevisionTag,
+					),
+				);
 
-			peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
-			this.pushCommitToTrunk(sequenceId, {
-				...newCommit,
-				change: newChangeFullyRebased.change,
-			});
+				this.telemetryEventBatcher?.accumulateAndLog({
+					duration,
+					...newChangeFullyRebased.telemetryProperties,
+				});
+
+				peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
+				this.pushCommitToTrunk(nextSequenceId, {
+					...newCommit,
+					sessionId,
+					change: newChangeFullyRebased.change,
+				});
+			}
+
+			nextSequenceId = getNextSequenceId(nextSequenceId);
 		}
 
+		// Step 3 - Rebase the local branch over the updated trunk.
 		this.localBranch.rebaseOnto(this.trunk);
 	}
 

package/src/shared-tree-core/resubmitMachine.ts

@@ -39,6 +39,8 @@ export interface ResubmitMachine<TChange> {
 
 	/**
 	 * Must be called after a sequenced commit is applied.
+	 * Note that this may be called multiples times in a row after a number of sequenced commits have been applied
+	 * (as opposed to always being called before the next sequenced commit is applied).
 	 * @param isLocal - whether the sequenced commit was generated by the local session.
 	 */
 	onSequencedCommitApplied(isLocal: boolean): void;

package/src/shared-tree-core/sharedTreeCore.ts

@@ -5,10 +5,11 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
+import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import type {
 	IExperimentalIncrementalSummaryContext,
+	IRuntimeMessageCollection,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -301,8 +302,9 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		if (this.detachedRevision !== undefined) {
 			const newRevision: SeqNumber = brand((this.detachedRevision as number) + 1);
 			this.detachedRevision = newRevision;
-			this.editManager.addSequencedChange(
-				{ ...enrichedCommit, sessionId: this.editManager.localSessionId },
+			this.editManager.addSequencedChanges(
+				[enrichedCommit],
+				this.editManager.localSessionId,
 				newRevision,
 				this.detachedRevision,
 			);
@@ -327,24 +329,68 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		this.resubmitMachine.onCommitSubmitted(enrichedCommit);
 	}
 
+	/**
+	 * Process a message from the runtime.
+	 * @deprecated - Use processMessagesCore to process a bunch of messages together.
+	 */
 	public processCore(
 		message: ISequencedDocumentMessage,
 		local: boolean,
 		localOpMetadata: unknown,
 	): void {
-		// Empty context object is passed in, as our decode function is schema-agnostic.
-		const { commit, sessionId } = this.messageCodec.decode(message.contents, {
-			idCompressor: this.idCompressor,
+		this.processMessagesCore({
+			envelope: message,
+			local,
+			messagesContent: [
+				{
+					clientSequenceNumber: message.clientSequenceNumber,
+					contents: message.contents,
+					localOpMetadata,
+				},
+			],
 		});
+	}
+
+	/**
+	 * Process a bunch of messages from the runtime. SharedObject will call this method with a bunch of messages.
+	 */
+	public processMessagesCore(messagesCollection: IRuntimeMessageCollection): void {
+		const { envelope, local, messagesContent } = messagesCollection;
+		const commits: GraphCommit<TChange>[] = [];
+		let messagesSessionId: SessionId | undefined;
+
+		// Get a list of all the commits from the messages.
+		for (const messageContent of messagesContent) {
+			// Empty context object is passed in, as our decode function is schema-agnostic.
+			const { commit, sessionId } = this.messageCodec.decode(messageContent.contents, {
+				idCompressor: this.idCompressor,
+			});
+			commits.push(commit);
+
+			if (messagesSessionId !== undefined) {
+				assert(
+					messagesSessionId === sessionId,
+					"All messages in a bunch must have the same session ID",
+				);
+			}
+			messagesSessionId = sessionId;
+		}
+
+		assert(messagesSessionId !== undefined, "Messages must have a session ID");
 
-		this.editManager.addSequencedChange(
-			{ ...commit, sessionId },
-			brand(message.sequenceNumber),
-			brand(message.referenceSequenceNumber),
+		this.editManager.addSequencedChanges(
+			commits,
+			messagesSessionId,
+			brand(envelope.sequenceNumber),
+			brand(envelope.referenceSequenceNumber),
 		);
-		this.resubmitMachine.onSequencedCommitApplied(local);
 
-		this.editManager.advanceMinimumSequenceNumber(brand(message.minimumSequenceNumber));
+		// Update the resubmit machine for each commit applied.
+		for (const _ of messagesContent) {
+			this.resubmitMachine.onSequencedCommitApplied(local);
+		}
+
+		this.editManager.advanceMinimumSequenceNumber(brand(envelope.minimumSequenceNumber));
 	}
 
 	public getLocalBranch(): SharedTreeBranch<TEditor, TChange> {

package/src/util/index.ts

@@ -56,6 +56,7 @@ export type {
 export { StackyIterator } from "./stackyIterator.js";
 export {
 	asMutable,
+	balancedReduce,
 	clone,
 	compareSets,
 	fail,

package/src/util/utils.ts

@@ -616,3 +616,35 @@ export function copyPropertyIfDefined<
 		}
 	}
 }
+
+/**
+ * Reduces an array of values into a single value.
+ * This is similar to `Array.prototype.reduce`,
+ * except that it recursively reduces the left and right halves of the input before reducing their respective reductions.
+ *
+ * When compared with an approach like reducing all the values left-to-right,
+ * this balanced approach is beneficial when the cost of invoking `callbackFn` is proportional to the number reduced values that its parameters collectively represent.
+ * For example, if `T` is an array, and `callbackFn` concatenates its inputs,
+ * then `balancedReduce` will have O(N*log(N)) time complexity instead of `Array.prototype.reduce`'s O(N²).
+ * However, if `callbackFn` is O(1) then both `balancedReduce` and `Array.prototype.reduce` will have O(N) complexity.
+ *
+ * @param array - The array to reduce.
+ * @param callbackFn - The function to execute for each pairwise reduction.
+ * @param emptyCase - A factory function that provides the value to return if the input array is empty.
+ */
+export function balancedReduce<T>(
+	array: readonly T[],
+	callbackFn: (left: T, right: T) => T,
+	emptyCase: () => T,
+): T {
+	if (hasSingle(array)) {
+		return array[0];
+	}
+	if (!hasSome(array)) {
+		return emptyCase();
+	}
+	const mid = Math.floor(array.length / 2);
+	const left = balancedReduce(array.slice(0, mid), callbackFn, emptyCase);
+	const right = balancedReduce(array.slice(mid), callbackFn, emptyCase);
+	return callbackFn(left, right);
+}