added functions to process the logs

Author: jouzz

README.md

@@ -3,7 +3,7 @@ Discrete event simulation library, inspired by GPSS and SimPy.
 
 ## Usage
 ```js
-import { Process, Sim, uniformInt, varExpo } from "https://deno.land/x/[email protected].5/mod.ts";
+import { Process, Sim, uniformInt, varExpo } from "https://deno.land/x/[email protected].6/mod.ts";
 
 const sim = new Sim();
 

mod.ts

@@ -26,6 +26,15 @@ export {
     writeResultsSync,
 } from "./src/sim.ts";
 
+export {
+    eCDF,
+    normalize,
+    accumulate,
+    asKeyVal,
+    queueLengthHistogram,
+    usageHistogram,
+} from "./src/logs.ts";
+
 export {
     queueLengthDistribution,
     queueLengthEvolution,

src/logs.ts

@@ -0,0 +1,56 @@
+import { ResourceUsageLog } from "./sim.ts";
+
+export function eCDF(eDist: number[], id?: string): {key:number, val:number}[] {
+    return asKeyVal(accumulate(normalize(eDist)), id);
+}
+
+export function normalize(x: number[]): number[] {
+    const total = x.reduce((p, c) => p + c, 0);
+    if(total === 0) throw "Cannot normalize if the sum is zero";
+    return x.map(v => v / total);
+}
+
+export function accumulate(x: number[]): number[] {
+    let prev = 0;
+    return x.map(x => {
+        prev += x;
+        return prev;
+    });
+}
+
+export function asKeyVal(x: number[], id?: string): {key:number, val:number, id?: string}[] {
+    return x.map((val, key) => (id === undefined ? {key, val} : {key, val, id}));
+}
+
+export function queueLengthHistogram(log: ResourceUsageLog[], from: number = 0): number[] {
+    const moves: {t:number, v:number}[] = [];
+    for(const ru of log){
+        moves.push({t:ru.rT, v:1});
+        if(ru.xqT !== undefined) moves.push({t:ru.xqT, v:-1});
+    }
+    return _composeMoves(moves, from);
+}
+
+export function usageHistogram(log: ResourceUsageLog[], from: number = 0): number[] {
+    const moves: {t:number, v:number}[] = [];
+    for(const ru of log){
+        if(ru.xqT !== undefined && ru.av !== undefined) moves.push({t:ru.xqT, v:ru.cap});
+        if(ru.lT !== undefined) moves.push({t:ru.lT, v:-(ru.fr ?? 0)});
+    }
+    return _composeMoves(moves, from);
+}
+
+export function _composeMoves(moves: {t:number, v:number}[], from: number) {
+    const cumul: number[] = [];
+    moves.sort((a,b) => a.t - b.t);
+    let ct = 0, cv = 0;
+    for(const {t, v} of moves){
+        if(t > from){
+            const time = t - Math.max(ct, from);
+            while(cumul.length <= cv) cumul.push(0);
+            cumul[cv] += time;
+        }
+        ct = t; cv += v;
+    }
+    return cumul;
+}

test/log.test.ts

@@ -0,0 +1,97 @@
+import { assertEquals } from "https://deno.land/[email protected]/assert/mod.ts";
+//import { ResourceUsageLog } from "../src/sim.ts";
+import { _composeMoves, accumulate, asKeyVal, normalize, queueLengthHistogram, usageHistogram } from "../src/logs.ts";
+
+Deno.test("asKey works", () => {
+    const actual = asKeyVal([1, 2, 3, 4]);
+    const expected = [{key:0, val:1}, {key:1, val:2}, {key:2, val:3}, {key:3, val:4}];
+    assertEquals(actual, expected);
+});
+
+Deno.test("normalize works", () => {
+    const actual = normalize([1, 2, 3, 4]);
+    const expected = [0.1, 0.2, 0.3, 0.4];
+    assertEquals(actual, expected);
+});
+
+Deno.test("accumulate works", () => {
+    const actual = accumulate([1, 2, 3, 4]);
+    const expected = [1, 3, 6, 10];
+    assertEquals(actual, expected);
+});
+
+Deno.test("queueLengthHistogram", () => {
+    const input = [
+        {pid:1, rid:1, pri:1, rT:0, cap:4, xqT:2},
+        {pid:2, rid:1, pri:1, rT:1, cap:2},
+    ];
+    const actual = queueLengthHistogram(input);
+    const expected: number[] = [0, 1, 1];
+    assertEquals(actual, expected);
+});
+
+Deno.test("usageHistogram", () => {
+    const input = [
+        {pid:1, rid:1, pri:1, rT:0, cap:4, xqT:2, av:10, lT:4, fr:4},
+        {pid:2, rid:1, pri:1, rT:1, cap:3, xqT:2.5, av:6, lT:3.5, fr:3},
+    ];
+    const actual = usageHistogram(input);
+    const expected: number[] = [2, 0, 0, 0, 1, 0, 0, 1];
+    assertEquals(actual, expected);
+});
+
+Deno.test("_composeMoves simple cases", () => {
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:1, v:-1},
+    ], 0), [0, 1]);
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:1, v:-1},
+        {t:2, v:1}, {t:3, v:-1},
+    ], 0), [1, 2]);
+});
+
+Deno.test("_composeMoves simple cases, with from", () => {
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:1, v:-1},
+    ], 0.5), [0, 0.5]);
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:1, v:-1},
+        {t:2, v:1}, {t:3, v:-1},
+    ], 2), [0, 1]);
+});
+
+Deno.test("_composeMoves overlap", () => {
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:2, v:-1},
+        {t:1, v:1}, {t:4, v:-1},
+    ], 0), [0, 3, 1]);
+    assertEquals(_composeMoves([
+        {t:1, v:1}, {t:4, v:-1},
+        {t:2, v:1}, {t:4, v:-1},
+        {t:3, v:1}, {t:4, v:-1},
+    ], 0), [1, 1, 1, 1]);
+    // same as previous, but shuffled
+    assertEquals(_composeMoves([
+        {t:4, v:-1}, {t:4, v:-1},
+        {t:4, v:-1},{t:3, v:1},
+        {t:2, v:1}, {t:1, v:1}, 
+    ], 0), [1, 1, 1, 1]);
+});
+
+Deno.test("_composeMoves overlap, with from", () => {
+    assertEquals(_composeMoves([
+        {t:0, v:1}, {t:2, v:-1},
+        {t:1, v:1}, {t:4, v:-1},
+    ], 1.5), [0, 2, 0.5]);
+    assertEquals(_composeMoves([
+        {t:1, v:1}, {t:4, v:-1},
+        {t:2, v:1}, {t:4, v:-1},
+        {t:3, v:1}, {t:4, v:-1},
+    ], 1.5), [0, 0.5, 1, 1]);
+    // same as previous, but shuffled
+    assertEquals(_composeMoves([
+        {t:4, v:-1}, {t:4, v:-1},
+        {t:4, v:-1},{t:3, v:1},
+        {t:2, v:1}, {t:1, v:1}, 
+    ], 1.5), [0, 0.5, 1, 1]);
+});