socket-function 1.1.4 → 1.1.5

package/SocketFunction.ts

@@ -17,6 +17,7 @@ import cborx from "cbor-x";
 import { setFlag } from "./require/compileFlags";
 import { isNode } from "./src/misc";
 import { getPendingCallCount, harvestCallTimes, harvestFailedCallCount } from "./src/CallFactory";
+import { measureWrap } from "./src/profiling/measure";
 
 setFlag(require, "cbor-x", "allowclient", true);
 let cborxInstance = new cborx.Encoder({ structuredClone: true });
@@ -72,8 +73,8 @@ export class SocketFunction {
     //  before it is changed, things just break. Also, it needs to be changed on both sides,
     //  or else things break. Also, it is very hard to detect when the issue is different serializers
     public static readonly WIRE_SERIALIZER = {
-        serialize: (obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)],
-        deserialize: (buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]),
+        serialize: measureWrap((obj: unknown): MaybePromise<Buffer[]> => [cborxInstance.encode(obj)], "WIRE_SERIALIZER|serialize"),
+        deserialize: measureWrap((buffers: Buffer[]): MaybePromise<unknown> => cborxInstance.decode(buffers[0]), "WIRE_SERIALIZER|deserialize"),
     };
 
     public static WIRE_WARN_TIME = 100;

package/index.d.ts

@@ -565,7 +565,7 @@ declare module "socket-function/src/args" {
 }
 
 declare module "socket-function/src/batching" {
-    import { AnyFunction } from "socket-function/src/types";
+    import { AnyFunction, MaybePromise } from "socket-function/src/types";
     export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
     export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
     export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
@@ -596,6 +596,13 @@ declare module "socket-function/src/batching" {
         minDelay?: number;
         maxDelay?: number;
     }): T;
+    export declare const safeLoop: typeof unblockLoop;
+    export declare const throttledLoop: typeof unblockLoop;
+    export declare function unblockLoop<T, R>(config: {
+        data: T[];
+        maxBlockingTime?: number;
+        backOffTime?: number;
+    } | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;
 
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "1.1.4",
+	"version": "1.1.5",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/CallFactory.ts

@@ -269,7 +269,7 @@ export async function createCallFactory(
                         let arg = originalArgs[0] as any;
                         fncHack = `.${arg.DomainName}.${arg.ModuleId}.${arg.FunctionId}`;
                     }
-                    console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
+                    console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + `B`).padEnd(4, " ")}\t${formatNumber(data.length)} buffers\tREMOTE CALL\t${call.classGuid}.${call.functionName}${fncHack} at ${Date.now()}`);
                 }
             }
             // If sending OR resultPromise throws, we want to error out. This solves some issues with resultPromise
@@ -449,6 +449,7 @@ export async function createCallFactory(
 
     let pendingCall: MessageHeader & {
         buffers: Buffer[];
+        firstReceivedTime?: number;
     } | undefined;
 
     async function processPendingCall() {
@@ -523,7 +524,6 @@ export async function createCallFactory(
         if (call.isReturn) {
             if (!SocketFunction.LEGACY_INITIALIZE && call.seqNum === INITIALIZE_STATE_SEQ_NUM) {
                 callFactory.receivedInitializeState = call.result as InitializeState;
-                console.log(green(`Received initialize state: ${JSON.stringify(callFactory.receivedInitializeState)}`));
                 return;
             }
             let callbackObj = pendingCalls.get(call.seqNum);
@@ -536,10 +536,10 @@ export async function createCallFactory(
             }
             if (SocketFunction.logMessages) {
                 let call = callbackObj.call;
-                console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
+                console.log(`SIZE\t${(formatNumberSuffixed(resultSize) + "B").padEnd(4, " ")}\t${formatNumber(currentBuffers.length)} buffers\tRETURN\t${call.classGuid}.${call.functionName} at ${Date.now()}, (${nodeId} / ${localNodeId})`);
             }
             if (call.isResultCompressed === "LZ4") {
-                call.result = await decompressObjLZ4(call.result as Buffer, receiveStats);
+                call.result = await decompressObjLZ4(call.result as Buffer[], receiveStats);
                 call.isResultCompressed = undefined;
             } else if (call.isResultCompressed === "zip" || call.isResultCompressed === true) {
                 call.result = await decompressObj(call.result as Buffer, receiveStats);
@@ -548,7 +548,7 @@ export async function createCallFactory(
             callbackObj.callback(call);
         } else {
             if (call.isArgsCompressed === "LZ4") {
-                call.args = await decompressObjLZ4(call.args as any as Buffer, sendStats) as any;
+                call.args = await decompressObjLZ4(call.args as any as Buffer[], sendStats) as any;
                 call.isArgsCompressed = undefined;
             } else if (call.isArgsCompressed === "zip" || call.isArgsCompressed === true) {
                 call.args = await decompressObj(call.args as any as Buffer, sendStats) as any;
@@ -576,12 +576,12 @@ export async function createCallFactory(
                 if (callFactory.receivedInitializeState?.supportsLZ4) {
                     let compressMode = shouldCompressCall(call);
                     if (compressMode !== false) {
-                        response.result = await compressObjLZ4(response.result, sendStats) as any;
+                        response.result = await compressObjLZ4(response.result, sendStats);
                         response.isResultCompressed = "LZ4";
                     }
                 } else {
                     if (shouldCompressCall(call)) {
-                        response.result = await compressObj(response.result, sendStats) as any;
+                        response.result = await compressObj(response.result, sendStats);
                         response.isResultCompressed = "zip";
                     }
                 }
@@ -693,11 +693,19 @@ export async function createCallFactory(
                 return;
             }
             if (message instanceof Buffer) {
-                if (message.byteLength > 1000 * 1000 * 10) {
-                    console.log(`Received large packet ${formatNumber(message.byteLength)}B at ${Date.now()}`);
-                }
                 if (!pendingCall) {
-                    throw new Error(`Received data without size`);
+                    throw new Error(`Received data without size ${message.byteLength}B, first 100 bytes: ${message.slice(0, 100).toString("hex")}`);
+                }
+                if (message.byteLength > 1000 * 1000 * 10 || pendingCall.bufferCount > 1000 && (pendingCall.buffers.length % 100 === 0)) {
+                    if (pendingCall.buffers.length === 0) {
+                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) at ${Date.now()}`);
+                    } else {
+                        let elapsed = Date.now() - (pendingCall.firstReceivedTime || 0);
+                        console.log(`Received large/many packets ${formatNumber(message.byteLength)}B (${pendingCall.buffers.length} / ${pendingCall.bufferCount}) after ${formatTime(elapsed)}`);
+                    }
+                }
+                if (pendingCall.buffers.length === 0) {
+                    pendingCall.firstReceivedTime = Date.now();
                 }
                 pendingCall.buffers.push(message);
                 if (pendingCall.buffers.length !== pendingCall.bufferCount) {
@@ -771,6 +779,9 @@ type CompressionStats = {
 
 const compressObj = measureWrap(async function wireCallCompress(obj: unknown, stats: CompressionStats): Promise<Buffer> {
     let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
+    if (buffers.length > 1) {
+        throw new Error("Legacy CompressObj only supports single buffer");
+    }
     let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
     let buffer = Buffer.concat([lengthBuffer, ...buffers]);
     stats.uncompressedSize += buffer.length;
@@ -794,27 +805,177 @@ const decompressObj = measureWrap(async function wireCallDecompress(obj: Buffer,
     return result;
 });
 
-const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer> {
-    let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
-    let lengthBuffer = Buffer.from((new Float64Array(buffers.map(x => x.length))).buffer);
-    let buffer = Buffer.concat([lengthBuffer, ...buffers]);
-    stats.uncompressedSize += buffer.length;
-    let result = LZ4.compress(buffer);
-    stats.compressedSize += result.length;
-    return result;
+const compressObjLZ4 = measureWrap(async function wireCallCompressLZ4(obj: unknown, stats: CompressionStats): Promise<Buffer[]> {
+    let headerParts: number[];
+    let dataBuffers: Buffer[];
+
+    if (obj instanceof Buffer) {
+        headerParts = [1];
+        dataBuffers = [obj];
+    } else if (Array.isArray(obj) && obj.every((x: any) => x instanceof Buffer)) {
+        let bufferArray = obj as Buffer[];
+        const TARGET_SIZE = 50 * 1024 * 1024;
+        const MIN_INDIVIDUAL_SIZE = 10 * 1024 * 1024;
+        const MAX_UNSPLIT_SIZE = 100 * 1024 * 1024;
+
+        let outputBuffers: Buffer[] = [];
+        let outputDescriptors: number[][] = [];
+        let currentGroup: Buffer[] = [];
+        let currentGroupSize = 0;
+
+        function flushCurrentGroup() {
+            if (currentGroup.length > 0) {
+                outputBuffers.push(Buffer.concat(currentGroup));
+                outputDescriptors.push(currentGroup.map(b => b.length));
+                currentGroup = [];
+                currentGroupSize = 0;
+            }
+        }
+
+        for (let buf of bufferArray) {
+            if (buf.length >= MIN_INDIVIDUAL_SIZE) {
+                flushCurrentGroup();
+
+                if (buf.length > MAX_UNSPLIT_SIZE) {
+                    let offset = 0;
+                    while (offset < buf.length) {
+                        let chunkSize = Math.min(TARGET_SIZE, buf.length - offset);
+                        outputBuffers.push(buf.slice(offset, offset + chunkSize));
+                        outputDescriptors.push([chunkSize]);
+                        offset += chunkSize;
+                    }
+                } else {
+                    outputBuffers.push(buf);
+                    outputDescriptors.push([buf.length]);
+                }
+            } else {
+                currentGroup.push(buf);
+                currentGroupSize += buf.length;
+
+                if (currentGroupSize >= TARGET_SIZE) {
+                    flushCurrentGroup();
+                }
+            }
+        }
+
+        flushCurrentGroup();
+
+        headerParts = [2, outputBuffers.length];
+        for (let descriptor of outputDescriptors) {
+            headerParts.push(descriptor.length, ...descriptor);
+        }
+        dataBuffers = outputBuffers;
+    } else {
+        let buffers = await SocketFunction.WIRE_SERIALIZER.serialize(obj);
+        headerParts = [3, buffers.length];
+        dataBuffers = buffers;
+    }
+
+    let headerBuffer = Buffer.from((new Float64Array(headerParts)).buffer);
+    let allBuffers = [headerBuffer, ...dataBuffers];
+
+    stats.uncompressedSize += allBuffers.reduce((sum, buf) => sum + buf.length, 0);
+
+    let compressed: Buffer[] = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentUncompressedSize = 0;
+    let currentCompressedSize = 0;
+
+    function logIfSlow(i: number) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 compress (${formatTime(elapsed)}: ${i + 1}/${allBuffers.length} buffers, ${formatNumber(currentUncompressedSize)}B => ${formatNumber(currentCompressedSize)}B`);
+            lastWarnTime = now;
+        }
+    }
+
+    for (let i = 0; i < allBuffers.length; i++) {
+        let buf = allBuffers[i];
+        currentUncompressedSize += buf.length;
+        let compressedBuf = LZ4.compress(buf);
+        compressed.push(compressedBuf);
+        currentCompressedSize += compressedBuf.length;
+
+        logIfSlow(i);
+    }
+    logIfSlow(allBuffers.length);
+
+    stats.compressedSize += currentCompressedSize;
+
+    return compressed;
 });
 
-const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer, stats: CompressionStats): Promise<unknown> {
-    let buffer = LZ4.decompress(obj);
-    stats.uncompressedSize += buffer.length - obj.length;
-    let lengthBuffer = buffer.slice(0, 8);
-    let lengths = new Float64Array(lengthBuffer.buffer, lengthBuffer.byteOffset, lengthBuffer.byteLength / 8);
-    let buffers: Buffer[] = [];
-    let offset = 8;
-    for (let length of lengths) {
-        buffers.push(buffer.slice(offset, offset + length));
-        offset += length;
+const decompressObjLZ4 = measureWrap(async function wireCallDecompressLZ4(obj: Buffer[], stats: CompressionStats): Promise<unknown> {
+    stats.compressedSize += obj.reduce((sum, buf) => sum + buf.length, 0);
+
+    let decompressed: Buffer[] = [];
+    let startTime = Date.now();
+    let lastWarnTime = startTime;
+    let currentCompressedSize = 0;
+    let currentUncompressedSize = 0;
+    function logIfSlow(i: number) {
+        let now = Date.now();
+        if (now - lastWarnTime > 500) {
+            let elapsed = now - startTime;
+            console.log(`Slow LZ4 decompress (${formatTime(elapsed)}): ${i + 1}/${obj.length} buffers, ${formatNumber(currentCompressedSize)}B => ${formatNumber(currentUncompressedSize)}B`);
+            lastWarnTime = now;
+        }
     }
-    let result = await SocketFunction.WIRE_SERIALIZER.deserialize(buffers);
-    return result;
+
+    for (let i = 0; i < obj.length; i++) {
+        let buf = obj[i];
+        currentCompressedSize += buf.length;
+        let decompressedBuf = LZ4.decompress(buf);
+        decompressed.push(decompressedBuf);
+        currentUncompressedSize += decompressedBuf.length;
+
+        logIfSlow(i);
+    }
+    logIfSlow(obj.length);
+
+    stats.uncompressedSize += currentUncompressedSize;
+
+    let headerBuffer = decompressed[0];
+    let dataBuffers = decompressed.slice(1);
+
+    let typeBuffer = headerBuffer.slice(0, 8);
+    let type = new Float64Array(typeBuffer.buffer, typeBuffer.byteOffset, 1)[0];
+
+    if (type === 1) {
+        return dataBuffers[0];
+    }
+
+    if (type === 2) {
+        let headerData = new Float64Array(headerBuffer.buffer, headerBuffer.byteOffset, headerBuffer.byteLength / 8);
+        let outputBufferCount = headerData[1];
+
+        let buffers: Buffer[] = [];
+        let headerIndex = 2;
+
+        for (let i = 0; i < outputBufferCount; i++) {
+            let inputBufferCount = headerData[headerIndex++];
+            let sizes: number[] = [];
+            for (let j = 0; j < inputBufferCount; j++) {
+                sizes.push(headerData[headerIndex++]);
+            }
+
+            let outputBuffer = dataBuffers[i];
+            let offset = 0;
+            for (let size of sizes) {
+                buffers.push(outputBuffer.slice(offset, offset + size));
+                offset += size;
+            }
+        }
+
+        return buffers;
+    }
+
+    if (type === 3) {
+        let result = await SocketFunction.WIRE_SERIALIZER.deserialize(dataBuffers);
+        return result;
+    }
+
+    throw new Error(`Unknown compression type ${type}`);
 });

package/src/batching.d.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from "./types";
+import { AnyFunction, MaybePromise } from "./types";
 export type DelayType = (number | "afterio" | "immediate" | "afterpromises" | "paintLoop" | "afterPaint");
 export declare function delay(delayTime: DelayType, immediateShortDelays?: "immediateShortDelays"): Promise<void>;
 export declare function batchFunctionNone<Arg, Result = void>(config: unknown, fnc: (arg: Arg[]) => (Promise<Result> | Result)): (arg: Arg) => Promise<Result>;
@@ -29,3 +29,10 @@ export declare function retryFunctional<T extends AnyFunction>(fnc: T, config?:
     minDelay?: number;
     maxDelay?: number;
 }): T;
+export declare const safeLoop: typeof unblockLoop;
+export declare const throttledLoop: typeof unblockLoop;
+export declare function unblockLoop<T, R>(config: {
+    data: T[];
+    maxBlockingTime?: number;
+    backOffTime?: number;
+} | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]>;

package/src/batching.ts

@@ -329,4 +329,41 @@ export function retryFunctional<T extends AnyFunction>(fnc: T, config?: {
     return async function (...args: any[]) {
         return await runFnc(args, maxRetries);
     } as any;
+}
+
+export const safeLoop = unblockLoop;
+export const throttledLoop = unblockLoop;
+export async function unblockLoop<T, R>(config: {
+    data: T[];
+    maxBlockingTime?: number;
+    backOffTime?: number;
+} | T[], fnc: (item: T) => MaybePromise<R>): Promise<R[]> {
+
+    let data = Array.isArray(config) ? config : config.data;
+    let maxBlockingTime = 300;
+    let backOffTime = 50;
+    if (!Array.isArray(config)) {
+        maxBlockingTime = config.maxBlockingTime ?? 300;
+        backOffTime = config.backOffTime ?? 50;
+    }
+
+    let lastYieldTime = Date.now();
+    let results: R[] = [];
+
+    for (let item of data) {
+        let result = fnc(item);
+
+        // If the function returns a promise, await it
+        if (result && typeof result === "object" && "then" in result) {
+            result = await result;
+        }
+        results.push(result);
+
+        // Check if we've been blocking for too long
+        if (Date.now() - lastYieldTime > maxBlockingTime) {
+            await delay(backOffTime);
+            lastYieldTime = Date.now();
+        }
+    }
+    return results;
 }