socket-function 0.9.3 → 0.9.4

package/src/nodeCache.ts

@@ -1,93 +1,93 @@
-import { CallFactory, createCallFactory } from "./CallFactory";
-import { MaybePromise } from "./types";
-import { lazy } from "./caching";
-import { SocketFunction } from "../SocketFunction";
-
-// TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
-//  This is only needed for memory management, and not for correctness. Entries never
-//  need to be refreshed, because NetworkLocation.listeningPorts shouldn't really change.
-//  Either we will have listeningPorts and re-establish the connection, or we won't, and
-//  then it is a client, in which case we cannot re-establish the connection (and we just
-//  have to wait for the client to re-establish it). AND, if the listeningPorts change from
-//  a value to a new value... then they should be obtained using connect() anyway,
-//  and so whatever way the user got the NetworkLocation to begin with, they should use again.
-
-export function getNodeId(domain: string, port: number): string {
-    // NOTE: As domains are never reused, this doesn't need any randomness
-    return `${domain}:${port}`;
-}
-
-/** A nodeId not available for reconnecting. */
-export function getClientNodeId(address: string): string {
-    return `client:${address}:${Date.now()}:${Math.random()}`;
-}
-export function isClientNodeId(nodeId: string): boolean {
-    return nodeId.startsWith("client:");
-}
-/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
- *      but we should always have an address).
- *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
- *  */
-export function getNodeIdIP(nodeId: string): string {
-    if (isClientNodeId(nodeId)) {
-        return nodeId.split(":")[1];
-    }
-    return getNodeIdLocation(nodeId)!.address;
-}
-
-export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
-    if (isClientNodeId(nodeId)) {
-        return undefined;
-    }
-    let [address, port] = nodeId.split(":");
-    return { address, port: parseInt(port) };
-}
-
-export function getNodeIdDomain(nodeId: string): string {
-    let location = getNodeIdLocation(nodeId);
-    if (!location) {
-        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
-    }
-    return new URL(location.address).hostname.split(".").slice(-2).join(".");
-}
-
-// NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called
-// nodeId => 
-const nodeCache = new Map<string, MaybePromise<CallFactory>>();
-
-// NOTE: Should be called directly inside call factory constructor whenever
-//      their nodeId changes (and on construction).
-export function registerNodeClient(callFactory: CallFactory) {
-    nodeCache.set(callFactory.nodeId, callFactory);
-    startCleanupLoop();
-}
-
-export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {
-    let callFactory = nodeCache.get(nodeId);
-    if (callFactory === undefined) {
-        callFactory = createCallFactory(undefined, nodeId);
-        nodeCache.set(nodeId, callFactory);
-    }
-    return callFactory;
-}
-export function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined> {
-    return nodeCache.get(nodeId);
-}
-
-const startCleanupLoop = lazy(() => {
-    (async () => {
-        while (true) {
-            for (let [key, value] of Array.from(nodeCache.entries())) {
-                let factory = value;
-                if (!(factory instanceof Promise)) {
-                    if (factory.closedForever) {
-                        nodeCache.delete(key);
-                    }
-                }
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000 * 60 * 5));
-        }
-    })().catch(e => {
-        console.error(`nodeCache cleanup loop failed, ${e.stack}`);
-    });
+import { CallFactory, createCallFactory } from "./CallFactory";
+import { MaybePromise } from "./types";
+import { lazy } from "./caching";
+import { SocketFunction } from "../SocketFunction";
+
+// TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
+//  This is only needed for memory management, and not for correctness. Entries never
+//  need to be refreshed, because NetworkLocation.listeningPorts shouldn't really change.
+//  Either we will have listeningPorts and re-establish the connection, or we won't, and
+//  then it is a client, in which case we cannot re-establish the connection (and we just
+//  have to wait for the client to re-establish it). AND, if the listeningPorts change from
+//  a value to a new value... then they should be obtained using connect() anyway,
+//  and so whatever way the user got the NetworkLocation to begin with, they should use again.
+
+export function getNodeId(domain: string, port: number): string {
+    // NOTE: As domains are never reused, this doesn't need any randomness
+    return `${domain}:${port}`;
+}
+
+/** A nodeId not available for reconnecting. */
+export function getClientNodeId(address: string): string {
+    return `client:${address}:${Date.now()}:${Math.random()}`;
+}
+export function isClientNodeId(nodeId: string): boolean {
+    return nodeId.startsWith("client:");
+}
+/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+ *      but we should always have an address).
+ *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+ *  */
+export function getNodeIdIP(nodeId: string): string {
+    if (isClientNodeId(nodeId)) {
+        return nodeId.split(":")[1];
+    }
+    return getNodeIdLocation(nodeId)!.address;
+}
+
+export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
+    if (isClientNodeId(nodeId)) {
+        return undefined;
+    }
+    let [address, port] = nodeId.split(":");
+    return { address, port: parseInt(port) };
+}
+
+export function getNodeIdDomain(nodeId: string): string {
+    let location = getNodeIdLocation(nodeId);
+    if (!location) {
+        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
+    }
+    return new URL(location.address).hostname.split(".").slice(-2).join(".");
+}
+
+// NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called
+// nodeId => 
+const nodeCache = new Map<string, MaybePromise<CallFactory>>();
+
+// NOTE: Should be called directly inside call factory constructor whenever
+//      their nodeId changes (and on construction).
+export function registerNodeClient(callFactory: CallFactory) {
+    nodeCache.set(callFactory.nodeId, callFactory);
+    startCleanupLoop();
+}
+
+export function getCreateCallFactory(nodeId: string): MaybePromise<CallFactory> {
+    let callFactory = nodeCache.get(nodeId);
+    if (callFactory === undefined) {
+        callFactory = createCallFactory(undefined, nodeId);
+        nodeCache.set(nodeId, callFactory);
+    }
+    return callFactory;
+}
+export function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined> {
+    return nodeCache.get(nodeId);
+}
+
+const startCleanupLoop = lazy(() => {
+    (async () => {
+        while (true) {
+            for (let [key, value] of Array.from(nodeCache.entries())) {
+                let factory = value;
+                if (!(factory instanceof Promise)) {
+                    if (factory.closedForever) {
+                        nodeCache.delete(key);
+                    }
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 1000 * 60 * 5));
+        }
+    })().catch(e => {
+        console.error(`nodeCache cleanup loop failed, ${e.stack}`);
+    });
 });

package/src/nodeProxy.ts

@@ -1,55 +1,55 @@
-import { lazy } from "./caching";
-import { FullCallType, SocketExposedInterface, SocketInternalInterface } from "../SocketFunctionTypes";
-
-type CallProxyType = {
-    [nodeId: string]: SocketInternalInterface;
-};
-
-export const getCallObj = Symbol.for("getCallObj");
-
-let proxyCache = new Map<string, CallProxyType>();
-export function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType {
-    let value = proxyCache.get(id);
-    if (!value) {
-        let nodeCache = new Map<string, CallProxyType[""]>();
-        value = new Proxy(Object.create(null), {
-            get(target, nodeId) {
-                if (typeof nodeId !== "string") return undefined;
-                let nodeProxy = nodeCache.get(nodeId);
-                if (!nodeProxy) {
-                    nodeProxy = new Proxy(Object.create(null), {
-                        get(target, functionName) {
-                            if (typeof functionName !== "string") return undefined;
-                            return Object.assign(
-                                (...args: unknown[]) => {
-                                    let call: FullCallType = {
-                                        classGuid: id,
-                                        nodeId,
-                                        functionName,
-                                        args,
-                                    };
-                                    return callback(call);
-                                },
-                                {
-                                    [getCallObj]: (...args: unknown[]) => {
-                                        let call: FullCallType = {
-                                            classGuid: id,
-                                            nodeId,
-                                            functionName,
-                                            args,
-                                        };
-                                        return call;
-                                    }
-                                }
-                            );
-                        }
-                    }) as CallProxyType[""];
-                    nodeCache.set(nodeId, nodeProxy);
-                }
-                return nodeProxy;
-            },
-        }) as CallProxyType;
-        proxyCache.set(id, value);
-    }
-    return value;
+import { lazy } from "./caching";
+import { FullCallType, SocketExposedInterface, SocketInternalInterface } from "../SocketFunctionTypes";
+
+type CallProxyType = {
+    [nodeId: string]: SocketInternalInterface;
+};
+
+export const getCallObj = Symbol.for("getCallObj");
+
+let proxyCache = new Map<string, CallProxyType>();
+export function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType {
+    let value = proxyCache.get(id);
+    if (!value) {
+        let nodeCache = new Map<string, CallProxyType[""]>();
+        value = new Proxy(Object.create(null), {
+            get(target, nodeId) {
+                if (typeof nodeId !== "string") return undefined;
+                let nodeProxy = nodeCache.get(nodeId);
+                if (!nodeProxy) {
+                    nodeProxy = new Proxy(Object.create(null), {
+                        get(target, functionName) {
+                            if (typeof functionName !== "string") return undefined;
+                            return Object.assign(
+                                (...args: unknown[]) => {
+                                    let call: FullCallType = {
+                                        classGuid: id,
+                                        nodeId,
+                                        functionName,
+                                        args,
+                                    };
+                                    return callback(call);
+                                },
+                                {
+                                    [getCallObj]: (...args: unknown[]) => {
+                                        let call: FullCallType = {
+                                            classGuid: id,
+                                            nodeId,
+                                            functionName,
+                                            args,
+                                        };
+                                        return call;
+                                    }
+                                }
+                            );
+                        }
+                    }) as CallProxyType[""];
+                    nodeCache.set(nodeId, nodeProxy);
+                }
+                return nodeProxy;
+            },
+        }) as CallProxyType;
+        proxyCache.set(id, value);
+    }
+    return value;
 }

package/src/profiling/getOwnTime.ts

@@ -1,143 +1,143 @@
-import debugbreak from "debugbreak";
-// TODO: We could probably make this an optional / dev dependency, to allow
-//  for use on machines without the ability to compile?
-import { now } from "rdtsc-now";
-
-export type OwnTimeObj = {
-    name: string;
-    time: number;
-    ownTime: number;
-};
-type OwnTimeObjInternal = OwnTimeObj & {
-    lastStartTime: number;
-    firstStartTime: number;
-    parent: OwnTimeObjInternal | undefined;
-    child: OwnTimeObjInternal | undefined;
-};
-
-let pendingCallTime: OwnTimeObjInternal | undefined;
-export function getPendingOwnTimeObjs(): (OwnTimeObj & { source: OwnTimeObjInternal })[] | undefined {
-    let time = now();
-    let instances = getPendingOwnTimeInstances();
-    if (!instances) return undefined;
-    if (!pendingCallTime) return undefined;
-    let results = instances.map((instance) => ({
-        name: instance.name,
-        ownTime: instance.ownTime,
-        time: time - instance.firstStartTime,
-        source: instance
-    }));
-    results[0].ownTime += time - pendingCallTime.lastStartTime;
-    return results;
-}
-export function getPendingOwnTimeInstances(): OwnTimeObjInternal[] | undefined {
-    if (!pendingCallTime) return undefined;
-    let results: OwnTimeObjInternal[] = [];
-    let current: OwnTimeObjInternal | undefined = pendingCallTime;
-    while (current) {
-        results.push(current);
-        current = current.parent;
-    }
-    return results;
-}
-(global as any).pendingOwnCallTime = pendingCallTime;
-
-// NOTE: This overhead time is actually mostly for aggregate time, but it is needed,
-//  otherwise we consistently underestimate the time spent.
-//  ALSO! This forces high count lines to be at the top of the aggregate time list, which is really important!
-// NOTE: The overhead time greatly varies, but even if it only takes 100ns, if 10X of that
-//  is significant, you are probably spending too much timing profiling anyway!
-export const measureOverheadTime = 500 / 1000 / 1000;
-// We internally add, because of where we measure time, there is time spent before we grab the
-//  current time, and after we record the last time, that is lost, but should be added.
-let addMeasureOverheadTime = 0;
-{
-    // NOTE: This is going to vary considerably. I assume because sometimes we are on a core
-    //  that is free, and other times we are on a core that is hyperthreading with another hardware
-    //  thread. This really hurts us because our timing uses rdtsc, which really hates hyper threading,
-    //  and can easily get 50% slower because of it.
-    let results: number[] = [];
-    for (let j = 0; j < 10; j++) {
-        const measureCount = 1000 * 10;
-        let time = now();
-        for (let i = 0; i < measureCount; i++) {
-            getOwnTime("test", () => { }, () => { });
-        }
-        time = now() - time;
-        let overhead = time / measureCount;
-        results.push(overhead);
-    }
-    results.sort((a, b) => a - b);
-    addMeasureOverheadTime = results[results.length / 2];
-}
-
-// TIMING: About 60ns, of which 40ns is just now() calls.
-//  If async is closer to 300ns.
-export function getOwnTime<T>(
-    name: string,
-    code: () => T,
-    onTime: (obj: OwnTimeObj) => void
-): T {
-    let time = now();
-    let obj: OwnTimeObjInternal = {
-        name,
-        time: 0,
-        ownTime: 0,
-        firstStartTime: time,
-        lastStartTime: time,
-        parent: pendingCallTime,
-        child: undefined,
-    };
-    if (pendingCallTime) {
-        pendingCallTime.child = obj;
-    }
-    pendingCallTime = obj;
-    if (obj.parent) {
-        obj.parent.ownTime += obj.lastStartTime - obj.parent.lastStartTime;
-    }
-
-    function finish() {
-        let time = now();
-        obj.time = time - obj.firstStartTime;
-        if (pendingCallTime === obj) {
-            // Good case, all of our children call ended before us.
-
-            // End our own time calculation
-            obj.ownTime += time - obj.lastStartTime;
-
-            // Our parent is now the last open call
-            pendingCallTime = obj.parent;
-            if (pendingCallTime) {
-                // Resume our parent ownTime counting
-                pendingCallTime.lastStartTime = time;
-            }
-        }
-        if (obj.child && obj.parent) {
-            obj.child.parent = obj.parent;
-            obj.parent.child = obj.child;
-        }
-        obj.parent = undefined;
-        obj.child = undefined;
-
-        obj.time += addMeasureOverheadTime;
-        obj.ownTime += addMeasureOverheadTime;
-
-        onTime(obj);
-    }
-
-    let isAsync = false;
-    try {
-        let result = code();
-        if (result && typeof result === "object" && result instanceof Promise) {
-            isAsync = true;
-            return result.finally(() => {
-                finish();
-            }) as any;
-        }
-        return result;
-    } finally {
-        if (!isAsync) {
-            finish();
-        }
-    }
+import debugbreak from "debugbreak";
+// TODO: We could probably make this an optional / dev dependency, to allow
+//  for use on machines without the ability to compile?
+import { now } from "rdtsc-now";
+
+export type OwnTimeObj = {
+    name: string;
+    time: number;
+    ownTime: number;
+};
+type OwnTimeObjInternal = OwnTimeObj & {
+    lastStartTime: number;
+    firstStartTime: number;
+    parent: OwnTimeObjInternal | undefined;
+    child: OwnTimeObjInternal | undefined;
+};
+
+let pendingCallTime: OwnTimeObjInternal | undefined;
+export function getPendingOwnTimeObjs(): (OwnTimeObj & { source: OwnTimeObjInternal })[] | undefined {
+    let time = now();
+    let instances = getPendingOwnTimeInstances();
+    if (!instances) return undefined;
+    if (!pendingCallTime) return undefined;
+    let results = instances.map((instance) => ({
+        name: instance.name,
+        ownTime: instance.ownTime,
+        time: time - instance.firstStartTime,
+        source: instance
+    }));
+    results[0].ownTime += time - pendingCallTime.lastStartTime;
+    return results;
+}
+export function getPendingOwnTimeInstances(): OwnTimeObjInternal[] | undefined {
+    if (!pendingCallTime) return undefined;
+    let results: OwnTimeObjInternal[] = [];
+    let current: OwnTimeObjInternal | undefined = pendingCallTime;
+    while (current) {
+        results.push(current);
+        current = current.parent;
+    }
+    return results;
+}
+(global as any).pendingOwnCallTime = pendingCallTime;
+
+// NOTE: This overhead time is actually mostly for aggregate time, but it is needed,
+//  otherwise we consistently underestimate the time spent.
+//  ALSO! This forces high count lines to be at the top of the aggregate time list, which is really important!
+// NOTE: The overhead time greatly varies, but even if it only takes 100ns, if 10X of that
+//  is significant, you are probably spending too much timing profiling anyway!
+export const measureOverheadTime = 500 / 1000 / 1000;
+// We internally add, because of where we measure time, there is time spent before we grab the
+//  current time, and after we record the last time, that is lost, but should be added.
+let addMeasureOverheadTime = 0;
+{
+    // NOTE: This is going to vary considerably. I assume because sometimes we are on a core
+    //  that is free, and other times we are on a core that is hyperthreading with another hardware
+    //  thread. This really hurts us because our timing uses rdtsc, which really hates hyper threading,
+    //  and can easily get 50% slower because of it.
+    let results: number[] = [];
+    for (let j = 0; j < 10; j++) {
+        const measureCount = 1000 * 10;
+        let time = now();
+        for (let i = 0; i < measureCount; i++) {
+            getOwnTime("test", () => { }, () => { });
+        }
+        time = now() - time;
+        let overhead = time / measureCount;
+        results.push(overhead);
+    }
+    results.sort((a, b) => a - b);
+    addMeasureOverheadTime = results[results.length / 2];
+}
+
+// TIMING: About 60ns, of which 40ns is just now() calls.
+//  If async is closer to 300ns.
+export function getOwnTime<T>(
+    name: string,
+    code: () => T,
+    onTime: (obj: OwnTimeObj) => void
+): T {
+    let time = now();
+    let obj: OwnTimeObjInternal = {
+        name,
+        time: 0,
+        ownTime: 0,
+        firstStartTime: time,
+        lastStartTime: time,
+        parent: pendingCallTime,
+        child: undefined,
+    };
+    if (pendingCallTime) {
+        pendingCallTime.child = obj;
+    }
+    pendingCallTime = obj;
+    if (obj.parent) {
+        obj.parent.ownTime += obj.lastStartTime - obj.parent.lastStartTime;
+    }
+
+    function finish() {
+        let time = now();
+        obj.time = time - obj.firstStartTime;
+        if (pendingCallTime === obj) {
+            // Good case, all of our children call ended before us.
+
+            // End our own time calculation
+            obj.ownTime += time - obj.lastStartTime;
+
+            // Our parent is now the last open call
+            pendingCallTime = obj.parent;
+            if (pendingCallTime) {
+                // Resume our parent ownTime counting
+                pendingCallTime.lastStartTime = time;
+            }
+        }
+        if (obj.child && obj.parent) {
+            obj.child.parent = obj.parent;
+            obj.parent.child = obj.child;
+        }
+        obj.parent = undefined;
+        obj.child = undefined;
+
+        obj.time += addMeasureOverheadTime;
+        obj.ownTime += addMeasureOverheadTime;
+
+        onTime(obj);
+    }
+
+    let isAsync = false;
+    try {
+        let result = code();
+        if (result && typeof result === "object" && result instanceof Promise) {
+            isAsync = true;
+            return result.finally(() => {
+                finish();
+            }) as any;
+        }
+        return result;
+    } finally {
+        if (!isAsync) {
+            finish();
+        }
+    }
 }