@mark1russell7/rigor-chaos 0.1.0 → 0.1.1

package/README.md

@@ -27,7 +27,8 @@ A schedule is data. A driver reads `times`, and it sends each arrival at its tim
 - `service` is the reply less the send. This is what a closed-loop driver measures.
 - `lag` is the send less the planned time.
 - `censored` holds the age at the end of each arrival with no reply. Each value is a lower bound of a latency.
+- `seconds` is optional. It holds the samples that the driver read of itself: the processor share, and the p99 and the largest delay of its event loop.
 
 `latencyQuantile` reads the latency and the censored values together, by the nearest rank. Thus an arrival with no reply does not leave the measure.
 
-`scheduleHeld` tells if the driver kept the schedule. A run that fails this check measures its driver, not its target. An A/A run with no fault examines this first.
+`scheduleHeld` tells if the driver kept the schedule. A run that fails this check measures its driver, not its target. An A/A run with no fault examines this first. When a run fails this check, `seconds` tells if a full processor or a held event loop made the sends late.

package/build/index.d.ts

@@ -1,3 +1,3 @@
 import { Arrivals, Phase, Profile, SCHEDULE_FORMAT, Schedule, ScheduleOptions, checkProfile, constant, expectedArrivals, ramp, schedule, spike, steps } from "./schedule.js";
-import { Completion, LoadMeasure, ScheduleCheck, latencyQuantile, measureLoad, scheduleHeld } from "./measure.js";
-export { type Arrivals, type Completion, type LoadMeasure, type Phase, type Profile, SCHEDULE_FORMAT, type Schedule, type ScheduleCheck, type ScheduleOptions, checkProfile, constant, expectedArrivals, latencyQuantile, measureLoad, ramp, schedule, scheduleHeld, spike, steps };
+import { Completion, LoadMeasure, ScheduleCheck, SecondSample, latencyQuantile, measureLoad, scheduleHeld } from "./measure.js";
+export { type Arrivals, type Completion, type LoadMeasure, type Phase, type Profile, SCHEDULE_FORMAT, type Schedule, type ScheduleCheck, type ScheduleOptions, type SecondSample, checkProfile, constant, expectedArrivals, latencyQuantile, measureLoad, ramp, schedule, scheduleHeld, spike, steps };

package/build/measure.d.ts

@@ -15,6 +15,20 @@ export interface Completion {
   /** This time is null for an arrival with no reply. */
   readonly done: number | null;
 }
+/**
+ * A second sample is what a driver process read of itself over one second of a run. It tells if a late
+ * send came from a full processor or from a held event loop. Each reading is optional.
+ */
+export interface SecondSample {
+  /** This time is the start of the second, in ms from the start of the schedule. */
+  readonly at: number;
+  /** This share is the processor time of the process over the time of the sample. One full core reads 1. */
+  readonly cpu?: number;
+  /** This time is the p99 of the delay of the event loop in this second, in ms. */
+  readonly loopP99?: number;
+  /** This time is the largest delay of the event loop in this second, in ms. */
+  readonly loopMax?: number;
+}
 /** This is the measure of one run of a schedule. Each list is in the order of the schedule. */
 export interface LoadMeasure {
   readonly planned: number;
@@ -30,13 +44,18 @@ export interface LoadMeasure {
   readonly lag: readonly number[];
   /** These times are the age at the end of each arrival with no reply. Each one is a lower bound of a latency. */
   readonly censored: readonly number[];
+  /** These samples are the seconds that the driver read, in order of time. A run with no list of samples has no such field. */
+  readonly seconds?: readonly SecondSample[];
 }
 /**
  * This function gives the measure of a run. `end` is the end of the run, in ms from the start of the
  * schedule. It throws a `RangeError` for an index outside the schedule and for two completions of
  * one index. It throws the same error for a reply before its send and for a time past `end`.
+ *
+ * `seconds` is optional, and the measure holds it as given. A sample must be in order and inside the
+ * run, and each reading must be finite and not negative. Otherwise the function throws the same error.
  */
-export declare function measureLoad(plan: Schedule, completions: readonly Completion[], end: number): LoadMeasure;
+export declare function measureLoad(plan: Schedule, completions: readonly Completion[], end: number, seconds?: readonly SecondSample[]): LoadMeasure;
 /**
  * This function gives a quantile of the latency, with each arrival with no reply at its lower bound.
  * With a censored value, the result is a lower bound of the true quantile. It uses the nearest rank,

package/build/measure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measure.d.ts","names":[],"sources":["../src/measure.ts"],"mappings":";;;;;;;;;;iBAaiB;;WAEN;WACA;;WAEA;;;iBAIM;WACN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;wBAQK,YAAY,MAAM,UAAU,sBAAsB,cAAc,cAAc;;;;;;wBAmC9E,gBAAgB,SAAS,aAAa;;iBAKrC;WACN;;WAEA;;WAEA;WACA;;;;;;;wBAQK,aAAa,SAAS,aAAa,gBAAgB"}
+{"version":3,"file":"measure.d.ts","names":[],"sources":["../src/measure.ts"],"mappings":";;;;;;;;;;iBAaiB;;WAEN;WACA;;WAEA;;;;;;iBAOM;;WAEN;;WAEA;;WAEA;;WAEA;;;iBAIM;WACN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,mBAAmB;;;;;;;;;;wBAwBd,YAAY,MAAM,UAAU,sBAAsB,cAAc,aAAa,mBAAmB,iBAAiB;;;;;;wBAoCjH,gBAAgB,SAAS,aAAa;;iBAKrC;WACN;;WAEA;;WAEA;WACA;;;;;;;wBAQK,aAAa,SAAS,aAAa,gBAAgB"}

package/build/measure.js

@@ -1,11 +1,29 @@
 import { quantile } from "@mark1russell7/rigor-statistics";
 // src/measure.ts
+/** This function throws a `RangeError` for a sample that a measure of this run cannot hold. */
+function checkSeconds(seconds, end) {
+	let last = Number.NEGATIVE_INFINITY;
+	for (const { at, cpu, loopP99, loopMax } of seconds) {
+		if (!(at >= 0 && at <= end && at > last)) throw new RangeError(`measureLoad: the sample at ${at} is not in order, in a run that stops at ${end}.`);
+		last = at;
+		for (const value of [
+			cpu,
+			loopP99,
+			loopMax
+		]) if (value !== void 0 && !(value >= 0 && Number.isFinite(value))) throw new RangeError(`measureLoad: the sample at ${at} has the reading ${value}.`);
+		if (loopP99 !== void 0 && loopMax !== void 0 && loopMax < loopP99) throw new RangeError(`measureLoad: the sample at ${at} has a largest delay of ${loopMax} under its p99 of ${loopP99}.`);
+	}
+}
 /**
 * This function gives the measure of a run. `end` is the end of the run, in ms from the start of the
 * schedule. It throws a `RangeError` for an index outside the schedule and for two completions of
 * one index. It throws the same error for a reply before its send and for a time past `end`.
+*
+* `seconds` is optional, and the measure holds it as given. A sample must be in order and inside the
+* run, and each reading must be finite and not negative. Otherwise the function throws the same error.
 */
-function measureLoad(plan, completions, end) {
+function measureLoad(plan, completions, end, seconds) {
+	if (seconds !== void 0) checkSeconds(seconds, end);
 	const byIndex = /* @__PURE__ */ new Map();
 	for (const completion of completions) {
 		if (!Number.isInteger(completion.index) || completion.index < 0 || completion.index >= plan.times.length) throw new RangeError(`measureLoad: the index ${completion.index} is not in the schedule of ${plan.times.length} arrivals.`);
@@ -37,7 +55,8 @@ function measureLoad(plan, completions, end) {
 		latency,
 		service,
 		lag,
-		censored
+		censored,
+		...seconds === void 0 ? {} : { seconds }
 	};
 }
 /**

package/build/measure.js.map

@@ -1 +1 @@
-{"version":3,"file":"measure.js","names":[],"sources":["../src/measure.ts"],"sourcesContent":["import { quantile } from \"@mark1russell7/rigor-statistics\";\nimport type { Schedule } from \"./schedule.ts\";\n\n/**\n * A closed-loop driver waits for a reply before its next request, thus a stall hides the requests\n * of its interval. This is coordinated omission. This module counts each latency from\n * the planned time, thus a stall counts in each arrival that it delayed.\n *\n * An arrival with no reply at the end of a run does not leave the measure. Its age at the end is a\n * lower bound of its latency, and a quantile reads it.\n */\n\n/** A completion is what a driver saw of one arrival. Its times are in ms from the start of the schedule. */\nexport interface Completion {\n  /** This number is the position of the arrival in the schedule. */\n  readonly index: number;\n  readonly sent: number;\n  /** This time is null for an arrival with no reply. */\n  readonly done: number | null;\n}\n\n/** This is the measure of one run of a schedule. Each list is in the order of the schedule. */\nexport interface LoadMeasure {\n  readonly planned: number;\n  /** This count is the number of arrivals that the driver did not send. */\n  readonly unsent: number;\n  /** This count is the number of arrivals that had no reply at the end of the run. */\n  readonly unfinished: number;\n  /** These times are the reply less the planned time: what a user waited. */\n  readonly latency: readonly number[];\n  /** These times are the reply less the send: the measure of a closed-loop driver. */\n  readonly service: readonly number[];\n  /** These times are the send less the planned time, for each arrival that the driver sent. */\n  readonly lag: readonly number[];\n  /** These times are the age at the end of each arrival with no reply. Each one is a lower bound of a latency. */\n  readonly censored: readonly number[];\n}\n\n/**\n * This function gives the measure of a run. `end` is the end of the run, in ms from the start of the\n * schedule. It throws a `RangeError` for an index outside the schedule and for two completions of\n * one index. It throws the same error for a reply before its send and for a time past `end`.\n */\nexport function measureLoad(plan: Schedule, completions: readonly Completion[], end: number): LoadMeasure {\n  const byIndex = new Map<number, Completion>();\n  for (const completion of completions) {\n    if (!Number.isInteger(completion.index) || completion.index < 0 || completion.index >= plan.times.length)\n      throw new RangeError(`measureLoad: the index ${completion.index} is not in the schedule of ${plan.times.length} arrivals.`);\n    if (byIndex.has(completion.index)) throw new RangeError(`measureLoad: the index ${completion.index} has two completions.`);\n    const last = completion.done ?? completion.sent;\n    if (!(completion.sent <= last && last <= end))\n      throw new RangeError(`measureLoad: the index ${completion.index} has a send at ${completion.sent} and a reply at ${completion.done}, in a run that stops at ${end}.`);\n    byIndex.set(completion.index, completion);\n  }\n  const latency: number[] = [];\n  const service: number[] = [];\n  const lag: number[] = [];\n  const censored: number[] = [];\n  let unfinished = 0;\n  plan.times.forEach((planned, index) => {\n    const completion = byIndex.get(index);\n    if (completion !== undefined) lag.push(completion.sent - planned);\n    if (completion === undefined || completion.done === null) {\n      if (completion !== undefined) unfinished += 1;\n      censored.push(Math.max(0, end - planned));\n      return;\n    }\n    latency.push(completion.done - planned);\n    service.push(completion.done - completion.sent);\n  });\n  return { planned: plan.times.length, unsent: plan.times.length - byIndex.size, unfinished, latency, service, lag, censored };\n}\n\n/**\n * This function gives a quantile of the latency, with each arrival with no reply at its lower bound.\n * With a censored value, the result is a lower bound of the true quantile. It uses the nearest rank,\n * thus the result is a measured value. It throws a `RangeError` for a run with no arrivals.\n */\nexport function latencyQuantile(measure: LoadMeasure, p: number): number {\n  return quantile([...measure.latency, ...measure.censored], p, \"nearest-rank\");\n}\n\n/** This is the check of a driver: the schedule held, or the reason that it did not. */\nexport interface ScheduleCheck {\n  readonly held: boolean;\n  /** This time is the largest size of a lag, or null with no send. */\n  readonly worst: number | null;\n  /** This count is the number of sends past the limit. */\n  readonly late: number;\n  readonly reason: string;\n}\n\n/**\n * This function tells if a driver kept the schedule: it sent each arrival, each within `limit` ms of\n * its planned time. A run that fails this check measures its driver, not the target, thus an A/A run\n * with no fault reads it first.\n */\nexport function scheduleHeld(measure: LoadMeasure, limit: number): ScheduleCheck {\n  const worst = measure.lag.reduce<number | null>((most, lag) => Math.max(most ?? 0, Math.abs(lag)), null);\n  const late = measure.lag.filter((lag) => Math.abs(lag) > limit).length;\n  const held = measure.unsent === 0 && late === 0;\n  const facts = `${measure.planned} planned, ${measure.unsent} not sent, ${late} past ${limit} ms, the worst ${worst ?? \"none\"} ms`;\n  return { held, worst, late, reason: `The driver ${held ? \"kept\" : \"did not keep\"} the schedule (${facts}).` };\n}\n"],"mappings":";;;;;;;AA2CA,SAAgB,YAAY,MAAgB,aAAoC,KAA0B;CACxG,MAAM,0BAAU,IAAI,IAAwB;CAC5C,KAAK,MAAM,cAAc,aAAa;EACpC,IAAI,CAAC,OAAO,UAAU,WAAW,KAAK,KAAK,WAAW,QAAQ,KAAK,WAAW,SAAS,KAAK,MAAM,QAChG,MAAM,IAAI,WAAW,0BAA0B,WAAW,MAAM,6BAA6B,KAAK,MAAM,OAAO,WAAW;EAC5H,IAAI,QAAQ,IAAI,WAAW,KAAK,GAAG,MAAM,IAAI,WAAW,0BAA0B,WAAW,MAAM,sBAAsB;EACzH,MAAM,OAAO,WAAW,QAAQ,WAAW;EAC3C,IAAI,EAAE,WAAW,QAAQ,QAAQ,QAAQ,MACvC,MAAM,IAAI,WAAW,0BAA0B,WAAW,MAAM,iBAAiB,WAAW,KAAK,kBAAkB,WAAW,KAAK,2BAA2B,IAAI,EAAE;EACtK,QAAQ,IAAI,WAAW,OAAO,UAAU;CAC1C;CACA,MAAM,UAAoB,CAAC;CAC3B,MAAM,UAAoB,CAAC;CAC3B,MAAM,MAAgB,CAAC;CACvB,MAAM,WAAqB,CAAC;CAC5B,IAAI,aAAa;CACjB,KAAK,MAAM,SAAS,SAAS,UAAU;EACrC,MAAM,aAAa,QAAQ,IAAI,KAAK;EACpC,IAAI,eAAe,KAAA,GAAW,IAAI,KAAK,WAAW,OAAO,OAAO;EAChE,IAAI,eAAe,KAAA,KAAa,WAAW,SAAS,MAAM;GACxD,IAAI,eAAe,KAAA,GAAW,cAAc;GAC5C,SAAS,KAAK,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC;GACxC;EACF;EACA,QAAQ,KAAK,WAAW,OAAO,OAAO;EACtC,QAAQ,KAAK,WAAW,OAAO,WAAW,IAAI;CAChD,CAAC;CACD,OAAO;EAAE,SAAS,KAAK,MAAM;EAAQ,QAAQ,KAAK,MAAM,SAAS,QAAQ;EAAM;EAAY;EAAS;EAAS;EAAK;CAAS;AAC7H;;;;;;AAOA,SAAgB,gBAAgB,SAAsB,GAAmB;CACvE,OAAO,SAAS,CAAC,GAAG,QAAQ,SAAS,GAAG,QAAQ,QAAQ,GAAG,GAAG,cAAc;AAC9E;;;;;;AAiBA,SAAgB,aAAa,SAAsB,OAA8B;CAC/E,MAAM,QAAQ,QAAQ,IAAI,QAAuB,MAAM,QAAQ,KAAK,IAAI,QAAQ,GAAG,KAAK,IAAI,GAAG,CAAC,GAAG,IAAI;CACvG,MAAM,OAAO,QAAQ,IAAI,QAAQ,QAAQ,KAAK,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC;CAChE,MAAM,OAAO,QAAQ,WAAW,KAAK,SAAS;CAC9C,MAAM,QAAQ,GAAG,QAAQ,QAAQ,YAAY,QAAQ,OAAO,aAAa,KAAK,QAAQ,MAAM,iBAAiB,SAAS,OAAO;CAC7H,OAAO;EAAE;EAAM;EAAO;EAAM,QAAQ,cAAc,OAAO,SAAS,eAAe,iBAAiB,MAAM;CAAI;AAC9G"}
+{"version":3,"file":"measure.js","names":[],"sources":["../src/measure.ts"],"sourcesContent":["import { quantile } from \"@mark1russell7/rigor-statistics\";\nimport type { Schedule } from \"./schedule.ts\";\n\n/**\n * A closed-loop driver waits for a reply before its next request, thus a stall hides the requests\n * of its interval. This is coordinated omission. This module counts each latency from\n * the planned time, thus a stall counts in each arrival that it delayed.\n *\n * An arrival with no reply at the end of a run does not leave the measure. Its age at the end is a\n * lower bound of its latency, and a quantile reads it.\n */\n\n/** A completion is what a driver saw of one arrival. Its times are in ms from the start of the schedule. */\nexport interface Completion {\n  /** This number is the position of the arrival in the schedule. */\n  readonly index: number;\n  readonly sent: number;\n  /** This time is null for an arrival with no reply. */\n  readonly done: number | null;\n}\n\n/**\n * A second sample is what a driver process read of itself over one second of a run. It tells if a late\n * send came from a full processor or from a held event loop. Each reading is optional.\n */\nexport interface SecondSample {\n  /** This time is the start of the second, in ms from the start of the schedule. */\n  readonly at: number;\n  /** This share is the processor time of the process over the time of the sample. One full core reads 1. */\n  readonly cpu?: number;\n  /** This time is the p99 of the delay of the event loop in this second, in ms. */\n  readonly loopP99?: number;\n  /** This time is the largest delay of the event loop in this second, in ms. */\n  readonly loopMax?: number;\n}\n\n/** This is the measure of one run of a schedule. Each list is in the order of the schedule. */\nexport interface LoadMeasure {\n  readonly planned: number;\n  /** This count is the number of arrivals that the driver did not send. */\n  readonly unsent: number;\n  /** This count is the number of arrivals that had no reply at the end of the run. */\n  readonly unfinished: number;\n  /** These times are the reply less the planned time: what a user waited. */\n  readonly latency: readonly number[];\n  /** These times are the reply less the send: the measure of a closed-loop driver. */\n  readonly service: readonly number[];\n  /** These times are the send less the planned time, for each arrival that the driver sent. */\n  readonly lag: readonly number[];\n  /** These times are the age at the end of each arrival with no reply. Each one is a lower bound of a latency. */\n  readonly censored: readonly number[];\n  /** These samples are the seconds that the driver read, in order of time. A run with no list of samples has no such field. */\n  readonly seconds?: readonly SecondSample[];\n}\n\n/** This function throws a `RangeError` for a sample that a measure of this run cannot hold. */\nfunction checkSeconds(seconds: readonly SecondSample[], end: number): void {\n  let last = Number.NEGATIVE_INFINITY;\n  for (const { at, cpu, loopP99, loopMax } of seconds) {\n    if (!(at >= 0 && at <= end && at > last)) throw new RangeError(`measureLoad: the sample at ${at} is not in order, in a run that stops at ${end}.`);\n    last = at;\n    for (const value of [cpu, loopP99, loopMax])\n      if (value !== undefined && !(value >= 0 && Number.isFinite(value))) throw new RangeError(`measureLoad: the sample at ${at} has the reading ${value}.`);\n    if (loopP99 !== undefined && loopMax !== undefined && loopMax < loopP99)\n      throw new RangeError(`measureLoad: the sample at ${at} has a largest delay of ${loopMax} under its p99 of ${loopP99}.`);\n  }\n}\n\n/**\n * This function gives the measure of a run. `end` is the end of the run, in ms from the start of the\n * schedule. It throws a `RangeError` for an index outside the schedule and for two completions of\n * one index. It throws the same error for a reply before its send and for a time past `end`.\n *\n * `seconds` is optional, and the measure holds it as given. A sample must be in order and inside the\n * run, and each reading must be finite and not negative. Otherwise the function throws the same error.\n */\nexport function measureLoad(plan: Schedule, completions: readonly Completion[], end: number, seconds?: readonly SecondSample[]): LoadMeasure {\n  if (seconds !== undefined) checkSeconds(seconds, end);\n  const byIndex = new Map<number, Completion>();\n  for (const completion of completions) {\n    if (!Number.isInteger(completion.index) || completion.index < 0 || completion.index >= plan.times.length)\n      throw new RangeError(`measureLoad: the index ${completion.index} is not in the schedule of ${plan.times.length} arrivals.`);\n    if (byIndex.has(completion.index)) throw new RangeError(`measureLoad: the index ${completion.index} has two completions.`);\n    const last = completion.done ?? completion.sent;\n    if (!(completion.sent <= last && last <= end))\n      throw new RangeError(`measureLoad: the index ${completion.index} has a send at ${completion.sent} and a reply at ${completion.done}, in a run that stops at ${end}.`);\n    byIndex.set(completion.index, completion);\n  }\n  const latency: number[] = [];\n  const service: number[] = [];\n  const lag: number[] = [];\n  const censored: number[] = [];\n  let unfinished = 0;\n  plan.times.forEach((planned, index) => {\n    const completion = byIndex.get(index);\n    if (completion !== undefined) lag.push(completion.sent - planned);\n    if (completion === undefined || completion.done === null) {\n      if (completion !== undefined) unfinished += 1;\n      censored.push(Math.max(0, end - planned));\n      return;\n    }\n    latency.push(completion.done - planned);\n    service.push(completion.done - completion.sent);\n  });\n  return { planned: plan.times.length, unsent: plan.times.length - byIndex.size, unfinished, latency, service, lag, censored, ...(seconds === undefined ? {} : { seconds }) };\n}\n\n/**\n * This function gives a quantile of the latency, with each arrival with no reply at its lower bound.\n * With a censored value, the result is a lower bound of the true quantile. It uses the nearest rank,\n * thus the result is a measured value. It throws a `RangeError` for a run with no arrivals.\n */\nexport function latencyQuantile(measure: LoadMeasure, p: number): number {\n  return quantile([...measure.latency, ...measure.censored], p, \"nearest-rank\");\n}\n\n/** This is the check of a driver: the schedule held, or the reason that it did not. */\nexport interface ScheduleCheck {\n  readonly held: boolean;\n  /** This time is the largest size of a lag, or null with no send. */\n  readonly worst: number | null;\n  /** This count is the number of sends past the limit. */\n  readonly late: number;\n  readonly reason: string;\n}\n\n/**\n * This function tells if a driver kept the schedule: it sent each arrival, each within `limit` ms of\n * its planned time. A run that fails this check measures its driver, not the target, thus an A/A run\n * with no fault reads it first.\n */\nexport function scheduleHeld(measure: LoadMeasure, limit: number): ScheduleCheck {\n  const worst = measure.lag.reduce<number | null>((most, lag) => Math.max(most ?? 0, Math.abs(lag)), null);\n  const late = measure.lag.filter((lag) => Math.abs(lag) > limit).length;\n  const held = measure.unsent === 0 && late === 0;\n  const facts = `${measure.planned} planned, ${measure.unsent} not sent, ${late} past ${limit} ms, the worst ${worst ?? \"none\"} ms`;\n  return { held, worst, late, reason: `The driver ${held ? \"kept\" : \"did not keep\"} the schedule (${facts}).` };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/rigor-chaos",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Open-loop load schedules with planned arrival times from a rate profile, and a measure of latency from the planned time with no coordinated omission.",
   "keywords": [
     "load",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@mark1russell7/rigor-generators": "^0.1.5",
-    "@mark1russell7/rigor-statistics": "^0.1.11"
+    "@mark1russell7/rigor-statistics": "^0.1.13"
   },
   "devDependencies": {
     "@mark1russell7/cue": "^2.0.0",