@fluidframework/matrix 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/handlecache.ts

@@ -18,116 +18,118 @@ import { ensureRange } from "./range";
  * so far there's no measurable perf penalty for being a separate object (node 12 x64)
  */
 export class HandleCache implements IVectorConsumer<Handle> {
-    private handles: Handle[] = [];
-    private start = 0;
-
-    constructor(public readonly vector: PermutationVector) { }
-
-    /**
-     * Returns the index of the given position in the 'handles' array as a Uint32.
-     * (If the position is not in the array, returns an integer greater than 'handles.length').
-     */
-    private getIndex(position: number) {
-        return (position - this.start) >>> 0;
-    }
-
-    /**
-     * Returns the handle currently assigned to the given 'position' (if any).  Check
-     * the result with 'isValidHandle(..)' to see if a handle has been allocated for
-     * the given position.
-     *
-     * Throws a 'RangeError' if the provided 'position' is out-of-bounds wrt. the
-     * PermutationVector's length.
-     */
-    public getHandle(position: number) {
-        const index = this.getIndex(position);
-
-        // Perf: To encourage inlining, handling of the 'cacheMiss(..)' case has been extracted
-        //       to a separate method.
-
-        // Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer
-        //       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an
-        //       ~40% speedup when the position is in the cache (node v12 x64).
-
-        return index < this.handles.length
-            ? this.handles[index]
-            : this.cacheMiss(position);
-    }
-
-    /** Update the cache when a handle has been allocated for a given position. */
-    public addHandle(position: number, handle: Handle) {
-        assert(isHandleValid(handle), 0x017 /* "Trying to add invalid handle!" */);
-
-        const index = this.getIndex(position);
-        if (index < this.handles.length) {
-            assert(!isHandleValid(this.handles[index]),
-                0x018 /* "Trying to insert handle into position with already valid handle!" */);
-            this.handles[index] = handle;
-        }
-    }
-
-    /** Used by 'CacheMiss()' to retrieve handles for a range of positions. */
-    private getHandles(start: number, end: number) {
-        // TODO: This can be accelerated substantially using 'walkSegments()'.  The only catch
-        //       is that
-
-        const handles: Handle[] = [];
-        const { vector } = this;
-
-        for (let pos = start; pos < end; pos++) {
-            const { segment, offset } = vector.getContainingSegment(pos);
-            const asPerm = segment as PermutationSegment;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            handles.push(asPerm.start + offset!);
-        }
-
-        return handles;
-    }
-
-    private cacheMiss(position: number) {
-        // Coercing 'position' to an Uint32 allows us to handle a negative 'position' value
-        // with the same logic that handles 'position' >= length.
-        const _position = position >>> 0;
-
-        // TODO: To bound memory usage, there should be a limit on the maximum size of
-        //       handle[].
-
-        // TODO: To reduce MergeTree lookups, this code should opportunistically grow
-        //       the cache to the next MergeTree segment boundary (within the limits of
-        //       the handle cache).
-
-        if (_position < this.start) {
-            this.handles = this.getHandles(_position, this.start).concat(this.handles);
-            this.start = _position;
-            return this.handles[0];
-        } else {
-            ensureRange(_position, this.vector.getLength());
-
-            this.handles = this.handles.concat(this.getHandles(this.start + this.handles.length, _position + 1));
-            return this.handles[this.handles.length - 1];
-        }
-    }
-
-    // #region IVectorConsumer
-
-    itemsChanged(start: number, removedCount: number, insertedCount: number): void {
-        // If positions were inserted/removed, our current policy is to trim the array
-        // at the beginning of the invalidate range and lazily repopulate the handles
-        // on demand.
-        //
-        // Some alternatives to consider that preserve the previously cached handles
-        // that are still valid:
-        //
-        //      * Eagerly populate the 'handles[]' with the newly insert values (currently guaranteed
-        //        to be Handle.unallocated, so we don't even need to look them up.)
-        //
-        //      * Use a sentinel value or other mechanism to allow "holes" in the cache.
-
-        const index = this.getIndex(start);
-        if (index < this.handles.length) {
-            this.handles.length = index;
-        }
-    }
-
-    // #endregion IVectorConsumer
+	private handles: Handle[] = [];
+	private start = 0;
+
+	constructor(public readonly vector: PermutationVector) {}
+
+	/**
+	 * Returns the index of the given position in the 'handles' array as a Uint32.
+	 * (If the position is not in the array, returns an integer greater than 'handles.length').
+	 */
+	private getIndex(position: number) {
+		return (position - this.start) >>> 0;
+	}
+
+	/**
+	 * Returns the handle currently assigned to the given 'position' (if any).  Check
+	 * the result with 'isValidHandle(..)' to see if a handle has been allocated for
+	 * the given position.
+	 *
+	 * Throws a 'RangeError' if the provided 'position' is out-of-bounds wrt. the
+	 * PermutationVector's length.
+	 */
+	public getHandle(position: number) {
+		const index = this.getIndex(position);
+
+		// Perf: To encourage inlining, handling of the 'cacheMiss(..)' case has been extracted
+		//       to a separate method.
+
+		// Perf: A cache hit implies that 'position' was in bounds.  Therefore, we can defer
+		//       checking that 'position' is in bounds until 'cacheMiss(..)'.  This yields an
+		//       ~40% speedup when the position is in the cache (node v12 x64).
+
+		return index < this.handles.length ? this.handles[index] : this.cacheMiss(position);
+	}
+
+	/** Update the cache when a handle has been allocated for a given position. */
+	public addHandle(position: number, handle: Handle) {
+		assert(isHandleValid(handle), 0x017 /* "Trying to add invalid handle!" */);
+
+		const index = this.getIndex(position);
+		if (index < this.handles.length) {
+			assert(
+				!isHandleValid(this.handles[index]),
+				0x018 /* "Trying to insert handle into position with already valid handle!" */,
+			);
+			this.handles[index] = handle;
+		}
+	}
+
+	/** Used by 'CacheMiss()' to retrieve handles for a range of positions. */
+	private getHandles(start: number, end: number) {
+		// TODO: This can be accelerated substantially using 'walkSegments()'.  The only catch
+		//       is that
+
+		const handles: Handle[] = [];
+		const { vector } = this;
+
+		for (let pos = start; pos < end; pos++) {
+			const { segment, offset } = vector.getContainingSegment(pos);
+			const asPerm = segment as PermutationSegment;
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			handles.push(asPerm.start + offset!);
+		}
+
+		return handles;
+	}
+
+	private cacheMiss(position: number) {
+		// Coercing 'position' to an Uint32 allows us to handle a negative 'position' value
+		// with the same logic that handles 'position' >= length.
+		const _position = position >>> 0;
+
+		// TODO: To bound memory usage, there should be a limit on the maximum size of
+		//       handle[].
+
+		// TODO: To reduce MergeTree lookups, this code should opportunistically grow
+		//       the cache to the next MergeTree segment boundary (within the limits of
+		//       the handle cache).
+
+		if (_position < this.start) {
+			this.handles = this.getHandles(_position, this.start).concat(this.handles);
+			this.start = _position;
+			return this.handles[0];
+		} else {
+			ensureRange(_position, this.vector.getLength());
+
+			this.handles = this.handles.concat(
+				this.getHandles(this.start + this.handles.length, _position + 1),
+			);
+			return this.handles[this.handles.length - 1];
+		}
+	}
+
+	// #region IVectorConsumer
+
+	itemsChanged(start: number, removedCount: number, insertedCount: number): void {
+		// If positions were inserted/removed, our current policy is to trim the array
+		// at the beginning of the invalidate range and lazily repopulate the handles
+		// on demand.
+		//
+		// Some alternatives to consider that preserve the previously cached handles
+		// that are still valid:
+		//
+		//      * Eagerly populate the 'handles[]' with the newly insert values (currently guaranteed
+		//        to be Handle.unallocated, so we don't even need to look them up.)
+		//
+		//      * Use a sentinel value or other mechanism to allow "holes" in the cache.
+
+		const index = this.getIndex(start);
+		if (index < this.handles.length) {
+			this.handles.length = index;
+		}
+	}
+
+	// #endregion IVectorConsumer
 }

package/src/handletable.ts

@@ -4,11 +4,11 @@
  */
 
 export const enum Handle {
-    /** Minimum valid handle. */
-    valid = 1,
+	/** Minimum valid handle. */
+	valid = 1,
 
-    /** Sentinel representing an unallocated Handle. */
-    unallocated = -0x80000000,
+	/** Sentinel representing an unallocated Handle. */
+	unallocated = -0x80000000,
 }
 
 export const isHandleValid = (handle: Handle) => handle >= Handle.valid;
@@ -17,71 +17,75 @@ export const isHandleValid = (handle: Handle) => handle >= Handle.valid;
  * A handle table provides a fast mapping from an integer `handle` to a value `T`.
  */
 export class HandleTable<T> {
-    // Note: the first slot of the 'handles' array is reserved to store the pointer to the first
-    //       free handle.  We initialize this slot with a pointer to slot '1', which will cause
-    //       us to delay allocate the following slot in the array on the first allocation.
-    public constructor(private readonly handles: (Handle | T)[] = [1]) { }
+	// Note: the first slot of the 'handles' array is reserved to store the pointer to the first
+	//       free handle.  We initialize this slot with a pointer to slot '1', which will cause
+	//       us to delay allocate the following slot in the array on the first allocation.
+	public constructor(private readonly handles: (Handle | T)[] = [1]) {}
 
-    public clear() {
-        // Restore the HandleTable's initial state by deleting all items in the handles array
-        // and then re-inserting the value '1' in the 0th slot.  (See comment at `handles` decl
-        // for explanation.)
-        this.handles.splice(0, this.handles.length, 1);
-    }
+	public clear() {
+		// Restore the HandleTable's initial state by deleting all items in the handles array
+		// and then re-inserting the value '1' in the 0th slot.  (See comment at `handles` decl
+		// for explanation.)
+		this.handles.splice(0, this.handles.length, 1);
+	}
 
-    /**
-     * Allocates and returns the next available handle.  Note that freed handles are recycled.
-     */
-    public allocate(): Handle {
-        const free = this.next;
-        this.next = (this.handles[free] as Handle) ?? (free + 1);
-        this.handles[free] = 0;
-        return free;
-    }
+	/**
+	 * Allocates and returns the next available handle.  Note that freed handles are recycled.
+	 */
+	public allocate(): Handle {
+		const free = this.next;
+		this.next = (this.handles[free] as Handle) ?? free + 1;
+		this.handles[free] = 0;
+		return free;
+	}
 
-    /**
-     * Allocates and returns the next available `count` handles.
-     */
-    public allocateMany(count: Handle) {
-        const handles = new Uint32Array(count);
-        for (let i = 0; i < count; i++) {
-            handles[i] = this.allocate();
-        }
-        return handles;
-    }
+	/**
+	 * Allocates and returns the next available `count` handles.
+	 */
+	public allocateMany(count: Handle) {
+		const handles = new Uint32Array(count);
+		for (let i = 0; i < count; i++) {
+			handles[i] = this.allocate();
+		}
+		return handles;
+	}
 
-    /**
-     * Returns the given handle to the free list.
-     */
-    public free(handle: Handle) {
-        this.handles[handle] = this.next;
-        this.next = handle;
-    }
+	/**
+	 * Returns the given handle to the free list.
+	 */
+	public free(handle: Handle) {
+		this.handles[handle] = this.next;
+		this.next = handle;
+	}
 
-    /**
-     * Get the value `T` associated with the given handle, if any.
-     */
-    public get(handle: Handle): T {
-        return this.handles[handle] as T;
-    }
+	/**
+	 * Get the value `T` associated with the given handle, if any.
+	 */
+	public get(handle: Handle): T {
+		return this.handles[handle] as T;
+	}
 
-    /**
-     * Set the value `T` associated with the given handle.
-     */
-    public set(handle: Handle, value: T) {
-        this.handles[handle] = value;
-    }
+	/**
+	 * Set the value `T` associated with the given handle.
+	 */
+	public set(handle: Handle, value: T) {
+		this.handles[handle] = value;
+	}
 
-    // Private helpers to get/set the head of the free list, which is stored in the 0th slot
-    // of the handle array.
-    private get next() { return this.handles[0] as Handle; }
-    private set next(handle: Handle) { this.handles[0] = handle; }
+	// Private helpers to get/set the head of the free list, which is stored in the 0th slot
+	// of the handle array.
+	private get next() {
+		return this.handles[0] as Handle;
+	}
+	private set next(handle: Handle) {
+		this.handles[0] = handle;
+	}
 
-    public getSummaryContent() {
-        return this.handles;
-    }
+	public getSummaryContent() {
+		return this.handles;
+	}
 
-    public static load<T>(data: (Handle | T)[]) {
-        return new HandleTable<T>(data);
-    }
+	public static load<T>(data: (Handle | T)[]) {
+		return new HandleTable<T>(data);
+	}
 }