mirror of
https://github.com/misskey-dev/misskey.git
synced 2026-07-25 07:25:04 +02:00
111 lines
2.9 KiB
TypeScript
111 lines
2.9 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: syuilo and misskey-project
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { measureMemoryUntilStable } from './memory-stability-util.mts';
|
|
|
|
function createTimer() {
|
|
let elapsedMs = 0;
|
|
|
|
return {
|
|
now: () => elapsedMs,
|
|
wait: async (durationMs: number) => {
|
|
elapsedMs += durationMs;
|
|
},
|
|
};
|
|
}
|
|
|
|
async function measure(readings: Record<string, number>[]) {
|
|
let readCount = 0;
|
|
const result = await measureMemoryUntilStable(
|
|
async () => readings[readCount++],
|
|
createTimer(),
|
|
);
|
|
return { result, readCount };
|
|
}
|
|
|
|
test('adopts the latest reading once Pss and Private_Dirty slopes converge', async () => {
|
|
const readings = [
|
|
{ Pss: 1000, Private_Dirty: 500, HeapUsed: 300 },
|
|
{ Pss: 1100, Private_Dirty: 520, HeapUsed: 310 },
|
|
{ Pss: 1200, Private_Dirty: 540, HeapUsed: 320 },
|
|
];
|
|
const { result, readCount } = await measure(readings);
|
|
|
|
assert.equal(readCount, 3);
|
|
assert.deepEqual(result.memoryUsage, readings[2]);
|
|
assert.deepEqual(result.stability, {
|
|
converged: true,
|
|
readingCount: 3,
|
|
elapsedMs: 4000,
|
|
maxAbsoluteSlopesKiBPerSecond: {
|
|
Pss: 50,
|
|
Private_Dirty: 10,
|
|
},
|
|
});
|
|
});
|
|
|
|
test('uses only the latest readings when determining convergence', async () => {
|
|
const readings = [
|
|
{ Pss: 1000, Private_Dirty: 500 },
|
|
{ Pss: 2000, Private_Dirty: 1000 },
|
|
{ Pss: 3000, Private_Dirty: 1500 },
|
|
{ Pss: 3040, Private_Dirty: 1520 },
|
|
{ Pss: 3080, Private_Dirty: 1540 },
|
|
];
|
|
const { result, readCount } = await measure(readings);
|
|
|
|
assert.equal(readCount, 5);
|
|
assert.equal(result.stability.converged, true);
|
|
assert.deepEqual(result.stability.maxAbsoluteSlopesKiBPerSecond, {
|
|
Pss: 20,
|
|
Private_Dirty: 10,
|
|
});
|
|
});
|
|
|
|
test('bounds the wait and reports the latest slopes when memory does not converge', async () => {
|
|
const readings = [
|
|
{ Pss: 1000, Private_Dirty: 500 },
|
|
{ Pss: 1600, Private_Dirty: 520 },
|
|
{ Pss: 2200, Private_Dirty: 540 },
|
|
{ Pss: 2800, Private_Dirty: 560 },
|
|
{ Pss: 3400, Private_Dirty: 580 },
|
|
{ Pss: 4000, Private_Dirty: 600 },
|
|
];
|
|
const { result, readCount } = await measure(readings);
|
|
|
|
assert.equal(readCount, 6);
|
|
assert.deepEqual(result.memoryUsage, readings[5]);
|
|
assert.deepEqual(result.stability, {
|
|
converged: false,
|
|
readingCount: 6,
|
|
elapsedMs: 10000,
|
|
maxAbsoluteSlopesKiBPerSecond: {
|
|
Pss: 300,
|
|
Private_Dirty: 10,
|
|
},
|
|
});
|
|
});
|
|
|
|
test('does not treat opposing adjacent slopes as convergence', async () => {
|
|
const readings = [
|
|
{ Pss: 1000, Private_Dirty: 500 },
|
|
{ Pss: 1600, Private_Dirty: 500 },
|
|
{ Pss: 1000, Private_Dirty: 500 },
|
|
{ Pss: 1600, Private_Dirty: 500 },
|
|
{ Pss: 1000, Private_Dirty: 500 },
|
|
{ Pss: 1600, Private_Dirty: 500 },
|
|
];
|
|
const { result, readCount } = await measure(readings);
|
|
|
|
assert.equal(readCount, 6);
|
|
assert.equal(result.stability.converged, false);
|
|
assert.deepEqual(result.stability.maxAbsoluteSlopesKiBPerSecond, {
|
|
Pss: 300,
|
|
Private_Dirty: 0,
|
|
});
|
|
});
|