// Auswertung des Server-Härtetests: liest die gesicherten Rohdaten und schreibt die Tabellen der Studie. // Aufruf: node auswertung.mjs // Vorab festgelegt (plan.json): Kapazität über p95-MSPT, Gültigkeit, Regel für Unterschiede. // Nachträglich ergänzt und als solche gekennzeichnet: Kapazität über die tatsächliche Taktrate (TPS ab 19,5) und die Kennzahlen bei 50 Bots. import fs from 'node:fs'; import path from 'node:path'; const [roh, ziel] = process.argv.slice(2); if (!roh || !ziel) { console.error('Aufruf: node auswertung.mjs '); process.exit(2); } fs.mkdirSync(ziel, { recursive: true }); const plan = JSON.parse(fs.readFileSync(path.join(roh, 'plan.json'), 'utf8')); const jsonl = (f) => (fs.existsSync(f) ? fs.readFileSync(f, 'utf8').split('\n').filter((z) => z.trim()).map((z) => JSON.parse(z)) : []); const r = (v, n = 2) => (v === null || v === undefined || Number.isNaN(v) ? null : Number(v.toFixed(n))); const median = (a) => { const s = [...a].sort((x, y) => x - y), n = s.length; return n ? (n % 2 ? s[(n - 1) / 2] : (s[n / 2 - 1] + s[n / 2]) / 2) : null; }; const mittel = (a) => (a.length ? a.reduce((x, y) => x + y, 0) / a.length : null); const TPS_GRENZE = 19.5; const VERGLEICHSSTUFE = 50; const NAMEN = { vanilla: 'Vanilla', paper: 'Paper', purpur: 'Purpur', 'fabric-lithium': 'Fabric + Lithium' }; const JVM = { aikar: 'Aikar-Flags', 'g1-standard': 'Standard-G1', 'zgc-generational': 'Generational ZGC' }; const kombi = Object.fromEntries(plan.kombinationen.map((k) => [k.kombination, k])); const anzeige = (k) => `${NAMEN[k.programm]}, ${JVM[k.jvm]}`; function kapazitaetTps(zeilen, grenze) { let k = 0; for (const z of zeilen) { if (z.tps !== null && z.tps >= grenze && (z.spieler_min ?? 0) >= z.n) k = z.n; else return { k, erreicht: true }; } return { k, erreicht: false }; } const stufen = [], laeufe = [], proben = []; const ordner = fs.readdirSync(path.join(roh, 'roh')).filter((d) => /^r\d\d-/.test(d)).sort(); for (const d of ordner) { const o = path.join(roh, 'roh', d); if (!fs.existsSync(path.join(o, 'bewertung.json'))) continue; const b = JSON.parse(fs.readFileSync(path.join(o, 'bewertung.json'), 'utf8')); const k = kombi[b.kombination]; const zeilen = jsonl(path.join(o, 'stufen.jsonl')); // Die Kapazität wird aus den Stufen neu berechnet und gegen die Bewertung während der Messung geprüft. let kap = 0; for (const z of zeilen) { if (z.p95 !== null && z.p95 < plan.grenzen.p95_ms && (z.spieler_min ?? 0) >= z.n && z.erreicht) kap = z.n; else break; } if (kap !== b.ergebnis?.kapazitaet) throw new Error(`${d}: Kapazität ${kap} weicht von der Bewertung ab`); const tpsKap = kapazitaetTps(zeilen, TPS_GRENZE); if (!tpsKap.erreicht) throw new Error(`${d}: TPS-Grenze im Raster nicht unterschritten`); const anKap = zeilen.find((z) => z.n === kap); const bei = zeilen.find((z) => z.n === VERGLEICHSSTUFE); laeufe.push({ lauf: d, kombination: b.kombination, anzeige: anzeige(k), programm: NAMEN[k.programm], jvm: JVM[k.jvm], wiederholung: b.wiederholung, versuch: b.versuch, reihenfolge: Number(d.slice(1, 3)), gueltig: b.gueltig, kapazitaet: kap, erste_ueberlast: b.ergebnis?.erste_ueberlast ?? null, tps_bei_kapazitaet: r(anKap?.tps, 3), kapazitaet_tps: tpsKap.k, kapazitaet_tps_190: kapazitaetTps(zeilen, 19).k, kapazitaet_tps_198: kapazitaetTps(zeilen, 19.8).k, p95_bei_50_ms: r(bei?.p95), p99_bei_50_ms: r(bei?.p99), tps_bei_50: r(bei?.tps, 3), stufen_gemessen: zeilen.length, ungueltig_grund: b.gruende.join(' | ') || null, }); for (const z of zeilen) { stufen.push({ lauf: d, kombination: b.kombination, anzeige: anzeige(k), programm: NAMEN[k.programm], jvm: JVM[k.jvm], wiederholung: b.wiederholung, lauf_gueltig: b.gueltig, spieler: z.n, spieler_min: z.spieler_min, unter_grenze: z.p95 !== null && z.p95 < plan.grenzen.p95_ms && (z.spieler_min ?? 0) >= z.n, p50_ms: r(z.p50), p95_ms: r(z.p95), p95_max_ms: r(z.p95_max), p99_ms: r(z.p99), mspt_mittel_ms: r(z.mspt_avg), tps: r(z.tps, 3), tps_min: r(z.tps_min, 3), ram_gb: r((z.rss_mb ?? 0) / 1024), cpu_server_pct: r(z.cpu_server), cpu_bots_pct: r(z.cpu_bots), steal_pct: r(z.steal, 3), bots_verzug_p99_ms: r(z.bots_verzug_p99_max), getrennt: z.getrennt_gesamt, proben: z.proben, }); } for (const p of jsonl(path.join(o, 'proben.jsonl'))) { proben.push({ lauf: d, kombination: b.kombination, spieler: p.n, zeit_unix: p.t, mspt_mittel_ms: p.mspt_avg, p50_ms: p.p50, p95_ms: p.p95, p99_ms: p.p99, tps: p.tps, spieler_verbunden: p.spieler, ram_gb: r((p.rss_mb ?? 0) / 1024), cpu_server_pct: p.cpu_server, cpu_bots_pct: p.cpu_bots, steal_pct: p.steal_alle }); } } if (!stufen.length) { console.error('Noch keine bewerteten Läufe'); process.exit(1); } const spanne = (w) => (w.length ? { min: Math.min(...w), max: Math.max(...w), median: median(w) } : { min: null, max: null, median: null }); const zusammenfassung = plan.kombinationen.map((k) => { const g = laeufe.filter((l) => l.kombination === k.kombination && l.gueltig); const kap = spanne(g.map((l) => l.kapazitaet)), tk = spanne(g.map((l) => l.kapazitaet_tps)); const p95 = spanne(g.map((l) => l.p95_bei_50_ms)), p99 = spanne(g.map((l) => l.p99_bei_50_ms)), tps = spanne(g.map((l) => l.tps_bei_kapazitaet)); const st50 = stufen.filter((s) => s.kombination === k.kombination && s.lauf_gueltig && s.spieler === VERGLEICHSSTUFE); return { kombination: k.kombination, anzeige: anzeige(k), programm: NAMEN[k.programm], jvm: JVM[k.jvm], im_programmvergleich: k.vergleich.includes('programm'), im_jvm_vergleich: k.vergleich.includes('jvm'), laeufe_gueltig: g.length, laeufe_ungueltig: laeufe.filter((l) => l.kombination === k.kombination && !l.gueltig).length, kapazitaet: kap.min, kapazitaet_median: kap.median, kapazitaet_max: kap.max, kapazitaet_tps: tk.min, kapazitaet_tps_median: tk.median, kapazitaet_tps_max: tk.max, tps_bei_kapazitaet_min: tps.min, p95_bei_50_min_ms: p95.min, p95_bei_50_max_ms: p95.max, p99_bei_50_min_ms: p99.min, p99_bei_50_max_ms: p99.max, ram_bei_50_gb: r(mittel(st50.map((s) => s.ram_gb))), cpu_bei_50_pct: r(mittel(st50.map((s) => s.cpu_server_pct))), }; }); // Unterschied nur, wenn sich die Spannen der drei Wiederholungen nicht überlappen (Regel aus plan.json). const vergleiche = []; const KENNZAHLEN = [ { kennzahl: 'kapazitaet_p95', art: 'vorab festgelegt', hoch: true, min: 'kapazitaet', max: 'kapazitaet_max' }, { kennzahl: 'kapazitaet_tps', art: 'nachträglich ergänzt', hoch: true, min: 'kapazitaet_tps', max: 'kapazitaet_tps_max' }, { kennzahl: 'p95_bei_50', art: 'nachträglich ergänzt', hoch: false, min: 'p95_bei_50_min_ms', max: 'p95_bei_50_max_ms' }, { kennzahl: 'p99_bei_50', art: 'nachträglich ergänzt', hoch: false, min: 'p99_bei_50_min_ms', max: 'p99_bei_50_max_ms' }, ]; for (const vgl of ['programm', 'jvm']) { const t = zusammenfassung.filter((z) => (vgl === 'programm' ? z.im_programmvergleich : z.im_jvm_vergleich) && z.laeufe_gueltig >= plan.wiederholungen); for (let i = 0; i < t.length; i++) for (let j = i + 1; j < t.length; j++) for (const K of KENNZAHLEN) { const [a, b] = [t[i], t[j]]; const getrennt = a[K.min] > b[K.max] || b[K.min] > a[K.max]; let besser = null; if (getrennt) besser = (a[K.min] > b[K.max]) === K.hoch ? a.anzeige : b.anzeige; vergleiche.push({ vergleich: vgl, kennzahl: K.kennzahl, regel: K.art, a: a.anzeige, a_min: a[K.min], a_max: a[K.max], b: b.anzeige, b_min: b[K.min], b_max: b[K.max], unterschied_belegt: getrennt, besser }); } } // Ergänzend: In wie vielen gemeinsamen Stufen trennen sich Aikar-Flags und Standard-G1 beim p99? const jeStufe = (kb, n) => stufen.filter((s) => s.kombination === kb && s.spieler === n).map((s) => s.p99_ms); const gemeinsam = plan.stufen.filter((n) => jeStufe('paper-aikar', n).length === 3 && jeStufe('paper-g1-standard', n).length === 3); const p99Stufen = gemeinsam.map((n) => { const a = jeStufe('paper-aikar', n), g = jeStufe('paper-g1-standard', n); return { spieler: n, aikar_min: Math.min(...a), aikar_max: Math.max(...a), g1_min: Math.min(...g), g1_max: Math.max(...g), aikar_niedriger: Math.max(...a) < Math.min(...g), g1_niedriger: Math.max(...g) < Math.min(...a) }; }); function csv(datei, zeilen) { const k = Object.keys(zeilen[0]); const zelle = (v) => { if (v === null || v === undefined) return ''; const s = String(v); return /[",\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s; }; fs.writeFileSync(path.join(ziel, datei), [k.join(','), ...zeilen.map((z) => k.map((x) => zelle(z[x])).join(','))].join('\n') + '\n'); } csv('daten.csv', stufen); csv('laeufe.csv', laeufe); csv('zusammenfassung.csv', zusammenfassung); csv('vergleiche.csv', vergleiche); csv('p99-aikar-g1.csv', p99Stufen); csv('proben.csv', proben); fs.writeFileSync(path.join(ziel, 'daten.json'), JSON.stringify({ daten: stufen }) + '\n'); const max = (f) => Math.max(...stufen.map((s) => s[f])); console.log(JSON.stringify({ laeufe: laeufe.length, gueltig: laeufe.filter((l) => l.gueltig).length, ungueltig: laeufe.filter((l) => !l.gueltig).length, stufen: stufen.length, proben: proben.length, steal_max: max('steal_pct'), bots_cpu_max: max('cpu_bots_pct'), bots_verzug_max: max('bots_verzug_p99_ms'), getrennt_max: max('getrennt'), von: laeufe.length })); for (const z of zusammenfassung) console.log(z.anzeige, '| p95-Kap', z.kapazitaet, z.kapazitaet_max, '| TPS-Kap', z.kapazitaet_tps, z.kapazitaet_tps_max, '| TPS an Kap min', z.tps_bei_kapazitaet_min, '| p95@50', z.p95_bei_50_min_ms, z.p95_bei_50_max_ms, '| p99@50', z.p99_bei_50_min_ms, z.p99_bei_50_max_ms, '| RAM', z.ram_bei_50_gb, 'CPU', z.cpu_bei_50_pct); for (const v of vergleiche) console.log(v.vergleich, v.kennzahl, v.a, `${v.a_min}-${v.a_max}`, 'vs', v.b, `${v.b_min}-${v.b_max}`, v.unterschied_belegt ? `BELEGT, besser: ${v.besser}` : 'nicht belegt'); console.log('p99 Aikar/G1 je Stufe:', p99Stufen.length, 'Stufen, Aikar niedriger', p99Stufen.filter((x) => x.aikar_niedriger).length, ', G1 niedriger', p99Stufen.filter((x) => x.g1_niedriger).length, ':', p99Stufen.filter((x) => x.aikar_niedriger).map((x) => x.spieler).join(','));