@fluidframework/id-compressor 2.0.0-rc.2.0.1 → 2.0.0-rc.3.0.0

package/lib/test/appendOnlySortedMap.spec.js

@@ -1,166 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/* eslint-disable no-bitwise */
-import { strict as assert } from "assert";
-import { AppendOnlySortedMap } from "../appendOnlySortedMap.js";
-import { compareFiniteNumbers } from "../utilities.js";
-import { assertNotUndefined } from "./testCommon.js";
-function runAppendOnlyMapTests(mapBuilder) {
-    it("detects out-of-order keys", () => {
-        const map = mapBuilder();
-        map.append(0, 0);
-        const exception = "Inserted key must be > all others in the map.";
-        assert.throws(() => map.append(-1, 1), (e) => e.message === exception);
-        map.append(1, 2);
-    });
-    it("can get the min and max keys", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        assert.equal(map.maxKey(), undefined);
-        for (let i = 0; i < elementCount; i++) {
-            map.append(i, i);
-            assert.equal(map.maxKey(), i);
-            assert.equal(map.minKey(), 0);
-        }
-    });
-    it("can get the first and last pairs", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        assert.equal(map.first(), undefined);
-        assert.equal(map.last(), undefined);
-        for (let i = 0; i < elementCount; i++) {
-            map.append(i, i);
-            assert.deepEqual(map.last(), [i, i]);
-            assert.deepEqual(map.first(), [0, 0]);
-        }
-    });
-    it("can get values", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        for (let i = 0; i < elementCount; i++) {
-            map.append(i, i);
-        }
-        assert.equal(map.get(-1), undefined);
-        assert.equal(map.get(10), undefined);
-        for (let i = 0; i < elementCount; i++) {
-            assert.equal(map.get(i), i);
-        }
-    });
-    it("can get pairs by index", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        for (let i = 0; i < elementCount; i++) {
-            map.append(i * 10, i);
-        }
-        assert.equal(map.getAtIndex(-1), undefined);
-        assert.equal(map.getAtIndex(10), undefined);
-        for (let i = 0; i < elementCount; i++) {
-            assert.deepEqual(map.getAtIndex(i), [i * 10, i]);
-        }
-    });
-    it("can get an entry or next lower by key", () => {
-        [99, 100].forEach((elementCount) => {
-            const map = mapBuilder();
-            for (let i = 0; i < elementCount; i++) {
-                map.append(i * 2, i * 2);
-            }
-            assert.equal(map.getPairOrNextLower(-1), undefined);
-            for (let i = 0; i < map.size; i++) {
-                assert.deepEqual(map.getPairOrNextLower(i * 2), [i * 2, i * 2]);
-                assert.deepEqual(map.getPairOrNextLower(i * 2 + 1), [i * 2, i * 2]);
-            }
-            const maxKey = assertNotUndefined(map.maxKey());
-            assert.deepEqual(map.getPairOrNextLower(maxKey + 1), [maxKey, maxKey]);
-        });
-    });
-    it("can get an entry or next higher by key", () => {
-        [99, 100].forEach((elementCount) => {
-            const map = mapBuilder();
-            for (let i = 0; i < elementCount; i++) {
-                map.append(i * 2, i * 2);
-            }
-            const minKey = assertNotUndefined(map.minKey());
-            assert.deepEqual(map.getPairOrNextHigher(minKey - 1), [minKey, minKey]);
-            for (let i = 0; i < map.size - 1; i++) {
-                assert.deepEqual(map.getPairOrNextHigher(i * 2), [i * 2, i * 2]);
-                assert.deepEqual(map.getPairOrNextHigher(i * 2 + 1), [i * 2 + 2, i * 2 + 2]);
-            }
-            assert.equal(map.getPairOrNextHigher(map.size * 2 + 1), undefined);
-        });
-    });
-    it("knows how big it is", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        for (let i = 0; i < elementCount; i++) {
-            assert.equal(map.size, i);
-            map.append(i, i);
-        }
-        assert.equal(map.size, elementCount);
-    });
-    it("can enumerate its keys and values", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        const keys = [];
-        const values = [];
-        for (let i = 0; i < elementCount; i++) {
-            const key = i;
-            const value = i * 2;
-            map.append(key, value);
-            keys.push(key);
-            values.push(value);
-        }
-        assert.deepEqual([...map.keys()], keys);
-        assert.deepEqual([...map.values()], values);
-    });
-    it("can calculate the indexOf a search element", () => {
-        const elements = [0, 0, 2, 0, 3, 0];
-        const comparator = (search, key, value) => {
-            return compareFiniteNumbers(search, key);
-        };
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, 0, comparator), 0);
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, 2, comparator), 2);
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, 3, comparator), 4);
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, -1, comparator), 0 ^ AppendOnlySortedMap.failureXor);
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, 1, comparator), 2 ^ AppendOnlySortedMap.failureXor);
-        assert.equal(AppendOnlySortedMap.keyIndexOf(elements, 10, comparator), 6 ^ AppendOnlySortedMap.failureXor);
-    });
-    describe("can perform range queries", () => {
-        const map = mapBuilder();
-        const elementCount = 10;
-        for (let i = 0; i < elementCount; i++) {
-            map.append(i * 2, i * 2);
-        }
-        const maxKey = assertNotUndefined(map.maxKey());
-        it("on empty ranges", () => {
-            assert.deepEqual([...map.getRange(1, -1)], []);
-            assert.deepEqual([...map.getRange(maxKey + 1, maxKey + 1)], []);
-        });
-        it("on ranges of size 1", () => {
-            assert.deepEqual([...map.getRange(0, 0)], [[0, 0]]);
-            assert.deepEqual([...map.getRange(1, 1)], []);
-            assert.deepEqual([...map.getRange(-1, -1)], []);
-        });
-        it("on non-empty ranges", () => {
-            assert.deepEqual([...map.getRange(0, 1)], [[0, 0]]);
-            assert.deepEqual([...map.getRange(0, 2)], [
-                [0, 0],
-                [2, 2],
-            ]);
-            assert.deepEqual([...map.getRange(1, 5)], [
-                [2, 2],
-                [4, 4],
-            ]);
-            const allEntries = [...map.entries()];
-            assert.deepEqual([...map.getRange(0, maxKey)], allEntries);
-            assert.deepEqual([...map.getRange(-maxKey, maxKey)], allEntries);
-            assert.deepEqual([...map.getRange(0, 2 * maxKey)], allEntries);
-            assert.deepEqual([...map.getRange(-maxKey, 2 * maxKey)], allEntries);
-        });
-    });
-}
-describe("AppendOnlySortedMap", () => {
-    runAppendOnlyMapTests(() => new AppendOnlySortedMap(compareFiniteNumbers));
-});
-//# sourceMappingURL=appendOnlySortedMap.spec.js.map

package/lib/test/idCompressor.perf.spec.js

@@ -1,281 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { benchmark, BenchmarkType } from "@fluid-tools/benchmark";
-import { assert } from "@fluidframework/core-utils";
-import { take } from "@fluid-private/stochastic-test-utils";
-import { IdCompressor } from "../idCompressor.js";
-import { createSessionId } from "../utilities.js";
-import { isFinalId, isLocalId, fail } from "./testCommon.js";
-import { Client, DestinationClient, IdCompressorTestNetwork, buildHugeCompressor, makeOpGenerator, performFuzzActions, sessionIds, } from "./idCompressorTestUtilities.js";
-const initialClusterCapacity = 512;
-describe("IdCompressor Perf", () => {
-    const type = BenchmarkType.Measurement;
-    const localClient = Client.Client1;
-    const remoteClient = Client.Client2;
-    let perfCompressor;
-    function setupCompressors(clusterSize, localClientCanEdit, synchronizeAtEnd) {
-        const perfNetwork = new IdCompressorTestNetwork(clusterSize);
-        const maxClusterSize = clusterSize * 2;
-        const generator = take(1000, makeOpGenerator({
-            validateInterval: 2000,
-            maxClusterSize,
-            outsideAllocationFraction: 0.9,
-        }));
-        performFuzzActions(generator, perfNetwork, Math.E, localClientCanEdit ? undefined : localClient, synchronizeAtEnd);
-        perfCompressor = perfNetwork.getCompressorUnsafeNoProxy(localClient);
-        return perfNetwork;
-    }
-    function getIdMadeBy(client, eagerFinal, network) {
-        const log = network.getIdLog(client);
-        for (let i = log.length - 1; i > 0; i--) {
-            const { id, originatingClient } = log[i];
-            if (originatingClient === client) {
-                if ((eagerFinal && isFinalId(id)) || (!eagerFinal && isLocalId(id))) {
-                    assert(eagerFinal === isFinalId(id), "Not local/final as requested.");
-                    return id;
-                }
-            }
-        }
-        fail("no ID found in log");
-    }
-    function benchmarkWithFlag(creator) {
-        for (const flag of [true, false]) {
-            creator(flag);
-        }
-    }
-    benchmark({
-        type,
-        title: `allocate local ID`,
-        before: () => {
-            setupCompressors(initialClusterCapacity, true, true);
-        },
-        benchmarkFn: () => {
-            perfCompressor.generateCompressedId();
-        },
-    });
-    benchmark({
-        type,
-        title: "take an ID creation range",
-        before: () => {
-            setupCompressors(initialClusterCapacity, true, true);
-        },
-        benchmarkFn: () => {
-            perfCompressor.generateCompressedId();
-            perfCompressor.takeNextCreationRange();
-        },
-    });
-    for (const clusterSize of [1, 10, 500, 1000]) {
-        const numIds = 7;
-        const session1 = "8150a099-5302-4672-b5f3-7a4492b59418";
-        const session2 = "f2ded886-92da-4248-967b-eb96ee04cf51";
-        let session = session1;
-        let nextFirstFinalizedGenCount1 = 1;
-        let nextFirstFinalizedGenCount2 = 1;
-        benchmark({
-            type,
-            title: `finalize a range of IDs (cluster size = ${clusterSize})`,
-            before: () => {
-                setupCompressors(clusterSize, false, true);
-            },
-            benchmarkFn: () => {
-                // Create a range with as minimal overhead as possible, as we'd like for this code to not exist
-                // in the timing loop at all (but benchmark forces us to do so)
-                const isFirstClient = session === session1;
-                const firstGenCount = isFirstClient
-                    ? nextFirstFinalizedGenCount1
-                    : nextFirstFinalizedGenCount2;
-                const range = {
-                    sessionId: session,
-                    ids: {
-                        firstGenCount,
-                        count: numIds,
-                        requestedClusterSize: initialClusterCapacity,
-                    },
-                };
-                perfCompressor.finalizeCreationRange(range);
-                const lastGenCount = firstGenCount + numIds;
-                if (isFirstClient) {
-                    nextFirstFinalizedGenCount1 = lastGenCount;
-                }
-                else {
-                    nextFirstFinalizedGenCount2 = lastGenCount;
-                }
-                // Alternate clients to sidestep optimization that packs them all into last cluster
-                session = isFirstClient ? session1 : session2;
-            },
-        });
-    }
-    benchmarkWithFlag((isLocal) => {
-        const remoteSessionId = sessionIds.get(remoteClient);
-        let opSpaceId;
-        benchmark({
-            type,
-            title: `normalize a ${isLocal ? "local" : "final"} ID from a remote session to session space`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, true, true);
-                const remoteSession = getIdMadeBy(remoteClient, false, network);
-                opSpaceId = (isLocal
-                    ? remoteSession
-                    : network.getCompressor(remoteClient).normalizeToOpSpace(remoteSession));
-            },
-            benchmarkFn: () => {
-                perfCompressor.normalizeToSessionSpace(opSpaceId, remoteSessionId);
-            },
-        });
-    });
-    benchmarkWithFlag((eagerFinal) => {
-        let id;
-        benchmark({
-            type,
-            title: `normalize a final ID corresponding to a ${eagerFinal ? "eager final" : "local"} ID from op space to the local session`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, true, true);
-                const opId = perfCompressor.normalizeToOpSpace(getIdMadeBy(localClient, eagerFinal, network));
-                assert(isFinalId(opId), "Must be final");
-                id = opId;
-            },
-            benchmarkFn: () => {
-                perfCompressor.normalizeToSessionSpace(id, perfCompressor.localSessionId);
-            },
-        });
-    });
-    benchmarkWithFlag((isLocalOriginator) => {
-        const remoteSessionId = sessionIds.get(remoteClient);
-        let opSpaceId;
-        benchmark({
-            type,
-            title: `normalize a final ID from a ${isLocalOriginator ? "local" : "remote"} session to a small session space (common case)`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, false, true);
-                // Ensure the local session has several different clusters
-                for (let clusterCount = 0; clusterCount < 5; clusterCount++) {
-                    network.allocateAndSendIds(localClient, 
-                    // eslint-disable-next-line @typescript-eslint/dot-notation
-                    perfCompressor["nextRequestedClusterSize"]);
-                    network.allocateAndSendIds(remoteClient, 
-                    // eslint-disable-next-line @typescript-eslint/dot-notation
-                    perfCompressor["nextRequestedClusterSize"] * 2);
-                    network.deliverOperations(DestinationClient.All);
-                }
-                const client = isLocalOriginator ? localClient : remoteClient;
-                const idFromSession = getIdMadeBy(client, true, network);
-                opSpaceId = network.getCompressor(client).normalizeToOpSpace(idFromSession);
-            },
-            benchmarkFn: () => {
-                perfCompressor.normalizeToSessionSpace(opSpaceId, remoteSessionId);
-            },
-        });
-    });
-    let unackedLocalId;
-    benchmark({
-        type,
-        title: `normalize an unacked local ID from the local session to op space`,
-        before: () => {
-            const network = setupCompressors(initialClusterCapacity, true, false);
-            // Ensure no eager finals
-            network.allocateAndSendIds(localClient, 
-            // eslint-disable-next-line @typescript-eslint/dot-notation
-            network.getCompressor(localClient)["nextRequestedClusterSize"] * 2 + 1);
-            unackedLocalId = getIdMadeBy(localClient, false, network);
-            assert(perfCompressor.normalizeToOpSpace(unackedLocalId) === unackedLocalId, "Local was acked.");
-        },
-        benchmarkFn: () => {
-            perfCompressor.normalizeToOpSpace(unackedLocalId);
-        },
-    });
-    benchmarkWithFlag((eagerFinal) => {
-        let id;
-        benchmark({
-            type,
-            title: `normalize an acked ${eagerFinal ? "eager final" : "local"} ID from the local session to op space`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, true, true);
-                id = getIdMadeBy(localClient, eagerFinal, network);
-            },
-            benchmarkFn: () => {
-                perfCompressor.normalizeToOpSpace(id);
-            },
-        });
-    });
-    benchmarkWithFlag((local) => {
-        let finalIdToDecompress;
-        benchmark({
-            type,
-            title: `decompress a final ID from a ${local ? "local" : "remote"} client into a stable ID`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, true, true);
-                finalIdToDecompress = getIdMadeBy(local ? localClient : remoteClient, true, network);
-            },
-            benchmarkFn: () => {
-                perfCompressor.decompress(finalIdToDecompress);
-            },
-        });
-    });
-    let localIdToDecompress;
-    benchmark({
-        type,
-        title: `decompress a local ID into a stable ID`,
-        before: () => {
-            const network = setupCompressors(initialClusterCapacity, true, true);
-            localIdToDecompress = getIdMadeBy(localClient, false, network);
-        },
-        benchmarkFn: () => {
-            perfCompressor.decompress(localIdToDecompress);
-        },
-    });
-    benchmarkWithFlag((eagerFinal) => {
-        let stableToCompress;
-        benchmark({
-            type,
-            title: `recompress a stable ID to a ${eagerFinal ? "local" : "final"} ID`,
-            before: () => {
-                const network = setupCompressors(initialClusterCapacity, true, true);
-                stableToCompress = perfCompressor.decompress(getIdMadeBy(localClient, eagerFinal, network));
-            },
-            benchmarkFn: () => {
-                perfCompressor.recompress(stableToCompress);
-            },
-        });
-    });
-    benchmarkWithFlag((manySessions) => {
-        benchmark({
-            type,
-            title: `serialize an IdCompressor (${manySessions ? "many sessions" : "many clusters"})`,
-            before: () => {
-                if (manySessions) {
-                    perfCompressor = buildHugeCompressor(undefined, initialClusterCapacity);
-                }
-                else {
-                    setupCompressors(initialClusterCapacity, false, true);
-                }
-            },
-            benchmarkFn: () => {
-                perfCompressor.serialize(false);
-            },
-        });
-    });
-    benchmarkWithFlag((manySessions) => {
-        let serialized;
-        const overrideRemoteSessionId = createSessionId();
-        benchmark({
-            type,
-            title: `deserialize an IdCompressor (${manySessions ? "many sessions" : "many clusters"})`,
-            before: () => {
-                if (manySessions) {
-                    perfCompressor = buildHugeCompressor(undefined, initialClusterCapacity);
-                }
-                else {
-                    setupCompressors(initialClusterCapacity, false, true);
-                }
-                serialized = perfCompressor.serialize(false);
-            },
-            benchmarkFn: () => {
-                IdCompressor.deserialize(serialized, overrideRemoteSessionId);
-            },
-        });
-    });
-});
-//# sourceMappingURL=idCompressor.perf.spec.js.map