@fluidframework/container-runtime 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/deltaScheduler.ts

@@ -6,14 +6,9 @@
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { performance } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
-import {
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-} from "@fluidframework/protocol-definitions";
-
-import {
-    TelemetryLogger,
-} from "@fluidframework/telemetry-utils";
+import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+
+import { TelemetryLogger } from "@fluidframework/telemetry-utils";
 /**
  * DeltaScheduler is responsible for the scheduling of inbound delta queue in cases where there
  * is more than one op a particular run of the queue. It does not schedule if there is just one
@@ -28,146 +23,159 @@ import {
  * processed, the time and number of turns it took to process the ops.
  */
 export class DeltaScheduler {
-    private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
-    // The time for processing ops in a single turn.
-    public static readonly processingTime = 50;
-
-    // The increase in time for processing ops after each turn.
-    private readonly processingTimeIncrement = 10;
-
-    private processingStartTime: number | undefined;
-    private currentAllowedProcessingTimeForTurn: number = DeltaScheduler.processingTime;
-
-    // This keeps track of the number of times inbound queue has been scheduled. After a particular
-    // count, we log telemetry for the number of ops processed, the time and number of turns it took
-    // to process the ops.
-    private schedulingCount: number = 0;
-
-    private schedulingLog: {
-        opsRemainingToProcess: number;
-        totalProcessingTime: number;
-        numberOfTurns: number;
-        numberOfBatchesProcessed: number;
-        lastSequenceNumber: number;
-        firstSequenceNumber: number;
-        startTime: number;
-    } | undefined;
-
-    constructor(
-        deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
-        private readonly logger: ITelemetryLogger,
-    ) {
-        this.deltaManager = deltaManager;
-        this.deltaManager.inbound.on("idle", () => { this.inboundQueueIdle(); });
-    }
-
-    public batchBegin(message: ISequencedDocumentMessage) {
-        if (!this.processingStartTime) {
-            this.processingStartTime = performance.now();
-        }
-        if (this.schedulingLog === undefined && this.schedulingCount % 500 === 0) {
-            // Every 500th time we are scheduling the inbound queue, we log telemetry for the
-            // number of ops processed, the time and number of turns it took to process the ops.
-            this.schedulingLog = {
-                opsRemainingToProcess: 0,
-                numberOfTurns: 1,
-                totalProcessingTime: 0,
-                numberOfBatchesProcessed: 0,
-                firstSequenceNumber: message.sequenceNumber,
-                lastSequenceNumber: message.sequenceNumber,
-                startTime: performance.now(),
-            };
-        }
-    }
-
-    public batchEnd(message: ISequencedDocumentMessage) {
-        if (this.schedulingLog) {
-            this.schedulingLog.numberOfBatchesProcessed++;
-            this.schedulingLog.lastSequenceNumber = message.sequenceNumber;
-            this.schedulingLog.opsRemainingToProcess = this.deltaManager.inbound.length;
-        }
-
-        if (this.shouldRunScheduler()) {
-            const currentTime = performance.now();
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const elapsedTime = currentTime - this.processingStartTime!;
-            if (elapsedTime > this.currentAllowedProcessingTimeForTurn) {
-                // We have processed ops for more than the total processing time. So, pause the
-                // queue, yield the thread and schedule a resume.
-
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.deltaManager.inbound.pause();
-
-                 // Increase the total processing time. Keep doing this after each turn until all the ops have
-                // been processed. This way we keep the responsiveness at the beginning while also making sure
-                // that all the ops process fairly quickly.
-                this.currentAllowedProcessingTimeForTurn += this.processingTimeIncrement;
-
-                // If we are logging the telemetry this time, update the telemetry log object.
-                if (this.schedulingLog) {
-                    this.schedulingLog.numberOfTurns++;
-                    this.schedulingLog.totalProcessingTime += elapsedTime;
-                }
-
-                setTimeout(() => {
-                    if (this.schedulingLog) {
-                        this.logger.sendTelemetryEvent({
-                            eventName: "InboundOpsPartialProcessingTime",
-                            duration: TelemetryLogger.formatTick(elapsedTime),
-                            opsProcessed: this.schedulingLog.lastSequenceNumber -
-                                this.schedulingLog.firstSequenceNumber + 1,
-                            opsRemainingToProcess: this.deltaManager.inbound.length,
-                            processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
-                            numberOfTurns: this.schedulingLog.numberOfTurns,
-                            batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-                            timeToResume: TelemetryLogger.formatTick(performance.now() - currentTime),
-                        });
-                    }
-                    this.deltaManager.inbound.resume();
-                });
-
-                this.processingStartTime = undefined;
-            }
-        }
-    }
-
-    private inboundQueueIdle() {
-        if (this.schedulingLog) {
-            // Add the time taken for processing the final ops to the total processing time in the
-            // telemetry log object.
-            const currentTime = performance.now();
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.schedulingLog.totalProcessingTime += currentTime - this.processingStartTime!;
-
-            this.logger.sendTelemetryEvent({
-                eventName: "InboundOpsProcessingTime",
-                opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
-                numberOfTurns: this.schedulingLog.numberOfTurns,
-                processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
-                opsProcessed: this.schedulingLog.lastSequenceNumber - this.schedulingLog.firstSequenceNumber + 1,
-                batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-                duration: TelemetryLogger.formatTick(currentTime - this.schedulingLog.startTime),
-                schedulingCount: this.schedulingCount,
-            });
-
-            this.schedulingLog = undefined;
-        }
-
-        // If we scheduled this batch of the inbound queue, increment the counter that tracks the
-        // number of times we have done this.
-        this.schedulingCount++;
-
-        // Reset the processing times.
-        this.processingStartTime = undefined;
-        this.currentAllowedProcessingTimeForTurn = DeltaScheduler.processingTime;
-    }
-
-    /**
-     * This function tells whether we should run the scheduler.
-     */
-    private shouldRunScheduler(): boolean {
-        // If there are still ops in the queue after the one we are processing now, we should
-        // run the scheduler.
-        return this.deltaManager.inbound.length > 0;
-    }
+	private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+	// The time for processing ops in a single turn.
+	public static readonly processingTime = 50;
+
+	// The increase in time for processing ops after each turn.
+	private readonly processingTimeIncrement = 10;
+
+	private processingStartTime: number | undefined;
+	private currentAllowedProcessingTimeForTurn: number = DeltaScheduler.processingTime;
+
+	// This keeps track of the number of times inbound queue has been scheduled. After a particular
+	// count, we log telemetry for the number of ops processed, the time and number of turns it took
+	// to process the ops.
+	private schedulingCount: number = 0;
+
+	private schedulingLog:
+		| {
+				opsRemainingToProcess: number;
+				totalProcessingTime: number;
+				numberOfTurns: number;
+				numberOfBatchesProcessed: number;
+				lastSequenceNumber: number;
+				firstSequenceNumber: number;
+				startTime: number;
+		  }
+		| undefined;
+
+	constructor(
+		deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
+		private readonly logger: ITelemetryLogger,
+	) {
+		this.deltaManager = deltaManager;
+		this.deltaManager.inbound.on("idle", () => {
+			this.inboundQueueIdle();
+		});
+	}
+
+	public batchBegin(message: ISequencedDocumentMessage) {
+		if (!this.processingStartTime) {
+			this.processingStartTime = performance.now();
+		}
+		if (this.schedulingLog === undefined && this.schedulingCount % 500 === 0) {
+			// Every 500th time we are scheduling the inbound queue, we log telemetry for the
+			// number of ops processed, the time and number of turns it took to process the ops.
+			this.schedulingLog = {
+				opsRemainingToProcess: 0,
+				numberOfTurns: 1,
+				totalProcessingTime: 0,
+				numberOfBatchesProcessed: 0,
+				firstSequenceNumber: message.sequenceNumber,
+				lastSequenceNumber: message.sequenceNumber,
+				startTime: performance.now(),
+			};
+		}
+	}
+
+	public batchEnd(message: ISequencedDocumentMessage) {
+		if (this.schedulingLog) {
+			this.schedulingLog.numberOfBatchesProcessed++;
+			this.schedulingLog.lastSequenceNumber = message.sequenceNumber;
+			this.schedulingLog.opsRemainingToProcess = this.deltaManager.inbound.length;
+		}
+
+		if (this.shouldRunScheduler()) {
+			const currentTime = performance.now();
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			const elapsedTime = currentTime - this.processingStartTime!;
+			if (elapsedTime > this.currentAllowedProcessingTimeForTurn) {
+				// We have processed ops for more than the total processing time. So, pause the
+				// queue, yield the thread and schedule a resume.
+
+				// eslint-disable-next-line @typescript-eslint/no-floating-promises
+				this.deltaManager.inbound.pause();
+
+				// Increase the total processing time. Keep doing this after each turn until all the ops have
+				// been processed. This way we keep the responsiveness at the beginning while also making sure
+				// that all the ops process fairly quickly.
+				this.currentAllowedProcessingTimeForTurn += this.processingTimeIncrement;
+
+				// If we are logging the telemetry this time, update the telemetry log object.
+				if (this.schedulingLog) {
+					this.schedulingLog.numberOfTurns++;
+					this.schedulingLog.totalProcessingTime += elapsedTime;
+				}
+
+				setTimeout(() => {
+					if (this.schedulingLog) {
+						this.logger.sendTelemetryEvent({
+							eventName: "InboundOpsPartialProcessingTime",
+							duration: TelemetryLogger.formatTick(elapsedTime),
+							opsProcessed:
+								this.schedulingLog.lastSequenceNumber -
+								this.schedulingLog.firstSequenceNumber +
+								1,
+							opsRemainingToProcess: this.deltaManager.inbound.length,
+							processingTime: TelemetryLogger.formatTick(
+								this.schedulingLog.totalProcessingTime,
+							),
+							numberOfTurns: this.schedulingLog.numberOfTurns,
+							batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
+							timeToResume: TelemetryLogger.formatTick(
+								performance.now() - currentTime,
+							),
+						});
+					}
+					this.deltaManager.inbound.resume();
+				});
+
+				this.processingStartTime = undefined;
+			}
+		}
+	}
+
+	private inboundQueueIdle() {
+		if (this.schedulingLog) {
+			// Add the time taken for processing the final ops to the total processing time in the
+			// telemetry log object.
+			const currentTime = performance.now();
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			this.schedulingLog.totalProcessingTime += currentTime - this.processingStartTime!;
+
+			this.logger.sendTelemetryEvent({
+				eventName: "InboundOpsProcessingTime",
+				opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
+				numberOfTurns: this.schedulingLog.numberOfTurns,
+				processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
+				opsProcessed:
+					this.schedulingLog.lastSequenceNumber -
+					this.schedulingLog.firstSequenceNumber +
+					1,
+				batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
+				duration: TelemetryLogger.formatTick(currentTime - this.schedulingLog.startTime),
+				schedulingCount: this.schedulingCount,
+			});
+
+			this.schedulingLog = undefined;
+		}
+
+		// If we scheduled this batch of the inbound queue, increment the counter that tracks the
+		// number of times we have done this.
+		this.schedulingCount++;
+
+		// Reset the processing times.
+		this.processingStartTime = undefined;
+		this.currentAllowedProcessingTimeForTurn = DeltaScheduler.processingTime;
+	}
+
+	/**
+	 * This function tells whether we should run the scheduler.
+	 */
+	private shouldRunScheduler(): boolean {
+		// If there are still ops in the queue after the one we are processing now, we should
+		// run the scheduler.
+		return this.deltaManager.inbound.length > 0;
+	}
 }

package/{garbageCollection.md → src/gc/garbageCollection.md}

@@ -1,35 +1,47 @@
 # Garbage Collection
+
 Garbage collection (GC) is the process by which Fluid Framework safely delete objects that are not used. The only responsibility of the users of Fluid Framework is to add and remove references to Fluid objects correctly.
 
 ## Why have Garbage Collection?
+
 GC reduces the size of the Fluid file at rest, the in-memory content and the summary that is uploaded to / downloaded from the server. It saves COGS on the server and it makes containers load faster as there is less data to download and process.
 
 ## What do I need to do?
+
 All Fluid objects that are in use must be properly referenced so that they are not deleted by GC. Similarly, references to all unused Fluid objects should be removed so that they can be deleted by GC. It is the responsibility of the users of Fluid Framework to correctly add and remove references to Fluid objects.
 
 ## How do I reference / unreference Fluid objects?
+
 Currently, the only Fluid objects that are eligible for GC are data stores and attachment blobs. The following sections describe how you can mark them as referenced or unreferenced. These sections speak of a "referenced DDS" which refers to a DDS that is created by a referenced data store.
+
 ### Data stores
+
 There are 2 ways to reference a data store:
-  - Store the data stores's handle (see [IFluidHandle](../../../common/lib/core-interfaces/src/handles.ts)) in a referenced DDS that supports handle in its data. For example, a data store's handle can be stored in a referenced `SharedMap` DDS.
+
+-   Store the data stores's handle (see [IFluidHandle](../../../../../packages/common/core-interfaces/src/handles.ts) in a referenced DDS that supports handle in its data. For example, a data store's handle can be stored in a referenced `SharedMap` DDS.
 
     Note that storing a handle of any of a data store's DDS will also mark the data store as referenced.
-  - Alias the data store. Aliased data stores are rooted in the container, i.e., they are always referenced and cannot be unreferenced later. Aliased data stores can never be deleted so only do so if you want them to live forever.
+
+-   Alias the data store. Aliased data stores are rooted in the container, i.e., they are always referenced and cannot be unreferenced later. Aliased data stores can never be deleted so only do so if you want them to live forever.
 
 Once there are no more referenced DDSes in the container containing a handle to a particular data store, that data store is unreferenced and is eligible for GC.
 
 > Note: There should be at least one aliased data store with at least one DDS in a container. This is the starting point for GC to look for other referenced objects in the container.
 
 ### Attachment blobs
+
 The only way to reference an attachment blob is to store its IFluidHandle in a referenced DDS similar to data stores.
 
 Once there are no more referenced DDSes in the container containing a handle to a particular attachment blob, that attachment blob is unreferenced and is eligible for GC.
 
 ## GC algorithm
+
 The GC algorithm runs in two phases:
 
 ### Mark phase
+
 In this phase, the GC algorithm identifies all Fluid objects that are unreferenced and marks them as such:
+
 1. It starts at the root (aliased) data stores and marks them and all their DDSes as referenced.
 2. It recursively finds the handles stored in referenced DDSes and marks the objects corresponding to the handles as referenced until is has scanned all objects.
 3. All the objects in the system that are not marked as referenced are marked as unreferenced. The unreferenced state of the object and timestamp of when it is unreferenced is added to the summary. The timestamp is used to determine how long the object has been unreferenced for and is used for the sweep phase.
@@ -38,9 +50,10 @@ Mark phase is enabled by default for a container. It is enabled during creation
 
 If you wish to disable this, set the `gcAllowed` option to `false` in `IGCRuntimeOptions`. These options are under `IContainerRuntimeOptions` and are passed to the container runtime during its creation. Note that this will disable GC permanently (including the sweep phase) for the container during its lifetime.
 
-See `IGCRuntimeOptions` in [containerRuntime.ts](./src/containerRuntime.ts) for more options to control GC behavior.
+See `IGCRuntimeOptions` in [containerRuntime.ts](../containerRuntime.ts) for more options to control GC behavior.
 
 ### Sweep phase
+
 In this phase, the GC algorithm identifies all Fluid objects that have been unreferenced for a specific amount of time (typically 30-40 days) and deletes them. Objects are only swept once the GC system is sure that they could never be referenced again by any active clients, i.e., clients that have the object in memory and could reference it.
 
 GC sweep phase has not been enabled yet. More details will be added here when sweep is enabled.