@fluidframework/container-runtime 2.0.0-dev.7.3.0.207781 → 2.0.0-dev.7.3.0.209023

package/src/opLifecycle/opGroupingManager.ts

@@ -5,6 +5,8 @@
 
 import { assert } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { ContainerMessageType } from "../messageTypes";
 import { IBatch } from "./definitions";
 
@@ -26,16 +28,38 @@ function isGroupContents(opContents: any): opContents is IGroupedBatchMessageCon
 	return opContents?.type === OpGroupingManager.groupedBatchOp;
 }
 
+export interface OpGroupingManagerConfig {
+	readonly groupedBatchingEnabled: boolean;
+	readonly opCountThreshold: number;
+	readonly reentrantBatchGroupingEnabled: boolean;
+}
+
 export class OpGroupingManager {
 	static readonly groupedBatchOp = "groupedBatch";
+	private readonly logger;
 
-	constructor(private readonly groupedBatchingEnabled: boolean) {}
+	constructor(
+		private readonly config: OpGroupingManagerConfig,
+		logger: ITelemetryBaseLogger,
+	) {
+		this.logger = createChildLogger({ logger, namespace: "OpGroupingManager" });
+	}
 
 	public groupBatch(batch: IBatch): IBatch {
-		if (batch.content.length < 2 || !this.groupedBatchingEnabled) {
+		if (!this.shouldGroup(batch)) {
 			return batch;
 		}
 
+		if (batch.content.length >= 1000) {
+			this.logger.sendTelemetryEvent({
+				eventName: "GroupLargeBatch",
+				length: batch.content.length,
+				threshold: this.config.opCountThreshold,
+				reentrant: batch.hasReentrantOps,
+				referenceSequenceNumber: batch.content[0].referenceSequenceNumber,
+			});
+		}
+
 		for (const message of batch.content) {
 			if (message.metadata) {
 				const keys = Object.keys(message.metadata);
@@ -86,4 +110,15 @@ export class OpGroupingManager {
 			compression: subMessage.compression,
 		}));
 	}
+
+	public shouldGroup(batch: IBatch): boolean {
+		return (
+			// Grouped batching must be enabled
+			this.config.groupedBatchingEnabled &&
+			// The number of ops in the batch must surpass the configured threshold
+			batch.content.length >= this.config.opCountThreshold &&
+			// Support for reentrant batches must be explicitly enabled
+			(this.config.reentrantBatchGroupingEnabled || batch.hasReentrantOps !== true)
+		);
+	}
 }

package/src/opLifecycle/outbox.ts

@@ -30,7 +30,6 @@ export interface IOutboxConfig {
 	// The maximum size of a batch that we can send over the wire.
 	readonly maxBatchSizeInBytes: number;
 	readonly disablePartialFlush: boolean;
-	readonly enableGroupedBatching: boolean;
 }
 
 export interface IOutboxParameters {
@@ -90,6 +89,7 @@ export class Outbox {
 	private readonly attachFlowBatch: BatchManager;
 	private readonly mainBatch: BatchManager;
 	private readonly blobAttachBatch: BatchManager;
+	private readonly idAllocationBatch: BatchManager;
 	private readonly defaultAttachFlowSoftLimitInBytes = 320 * 1024;
 	private batchRebasesToReport = 5;
 	private rebasing = false;
@@ -115,6 +115,7 @@ export class Outbox {
 		this.attachFlowBatch = new BatchManager({ hardLimit, softLimit });
 		this.mainBatch = new BatchManager({ hardLimit });
 		this.blobAttachBatch = new BatchManager({ hardLimit });
+		this.idAllocationBatch = new BatchManager({ hardLimit });
 	}
 
 	public get messageCount(): number {
@@ -231,6 +232,37 @@ export class Outbox {
 		}
 	}
 
+	public submitIdAllocation(message: BatchMessage) {
+		this.maybeFlushPartialBatch();
+
+		if (
+			!this.idAllocationBatch.push(
+				message,
+				this.isContextReentrant(),
+				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+			)
+		) {
+			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+			// when queue is not empty.
+			// Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+			this.flushInternal(this.idAllocationBatch);
+
+			this.addMessageToBatchManager(this.idAllocationBatch, message);
+		}
+
+		// If compression is enabled, we will always successfully receive
+		// attach ops and compress then send them at the next JS turn, regardless
+		// of the overall size of the accumulated ops in the batch.
+		// However, it is more efficient to flush these ops faster, preferably
+		// after they reach a size which would benefit from compression.
+		if (
+			this.idAllocationBatch.contentSizeInBytes >=
+			this.params.config.compressionOptions.minimumBatchSizeInBytes
+		) {
+			this.flushInternal(this.idAllocationBatch);
+		}
+	}
+
 	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
 		if (
 			!batchManager.push(
@@ -259,6 +291,7 @@ export class Outbox {
 	}
 
 	private flushAll() {
+		this.flushInternal(this.idAllocationBatch);
 		this.flushInternal(this.attachFlowBatch);
 		this.flushInternal(this.blobAttachBatch, true /* disableGroupedBatching */);
 		this.flushInternal(this.mainBatch);
@@ -270,7 +303,10 @@ export class Outbox {
 		}
 
 		const rawBatch = batchManager.popBatch();
-		if (rawBatch.hasReentrantOps === true && this.params.config.enableGroupedBatching) {
+		if (
+			rawBatch.hasReentrantOps === true &&
+			this.params.groupingManager.shouldGroup(rawBatch)
+		) {
 			assert(!this.rebasing, 0x6fa /* A rebased batch should never have reentrant ops */);
 			// If a batch contains reentrant ops (ops created as a result from processing another op)
 			// it needs to be rebased so that we can ensure consistent reference sequence numbers

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev.7.3.0.207781";
+export const pkgVersion = "2.0.0-dev.7.3.0.209023";

package/src/pendingStateManager.ts

@@ -11,7 +11,7 @@ import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { DataProcessingError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 
-import { ContainerMessageType, InboundSequencedContainerRuntimeMessage } from "./messageTypes";
+import { InboundSequencedContainerRuntimeMessage } from "./messageTypes";
 import { pkgVersion } from "./packageVersion";
 import { IBatchMetadata } from "./metadata";
 
@@ -128,18 +128,9 @@ export class PendingStateManager implements IDisposable {
 			return {
 				pendingStates: [...this.savedOps, ...this.pendingMessages.toArray()].map(
 					(message) => {
-						let content = message.content;
-						const parsedContent = JSON.parse(content);
-						// IdAllocations need their localOpMetadata stashed in the contents
-						// of the op to correctly resume the session when processing stashed ops
-						if (parsedContent.type === ContainerMessageType.IdAllocation) {
-							parsedContent.contents.stashedState = message.localOpMetadata;
-							content = JSON.stringify(parsedContent);
-						}
-
 						// delete localOpMetadata since it may not be serializable
 						// and will be regenerated by applyStashedOp()
-						return { ...message, content, localOpMetadata: undefined };
+						return { ...message, localOpMetadata: undefined };
 					},
 				),
 			};