// Baut studie.json und liesmich.txt aus den Tabellen der Auswertung. Jede Zahl im Text kommt aus den CSV-Dateien. // Aufruf: node baue-studie.mjs import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; const [roh, ziel] = process.argv.slice(2); function liesCsv(d) { const z = fs.readFileSync(path.join(ziel, d), 'utf8').trim().split('\n'); const teile = (s) => { const a = []; let c = '', q = false; for (let i = 0; i < s.length; i++) { const x = s[i]; if (q) { if (x === '"' && s[i + 1] === '"') { c += '"'; i++; } else if (x === '"') q = false; else c += x; } else if (x === '"') q = true; else if (x === ',') { a.push(c); c = ''; } else c += x; } a.push(c); return a; }; const k = teile(z[0]); return z.slice(1).map((l) => Object.fromEntries(teile(l).map((v, i) => [k[i], v]))); } const n = (v) => Number(v); const de = (v, s = 0) => Number(v).toFixed(s).replace('.', ','); const stufen = liesCsv('daten.csv'), laeufe = liesCsv('laeufe.csv'), zus = liesCsv('zusammenfassung.csv'), p99 = liesCsv('p99-aikar-g1.csv'), vgl = liesCsv('vergleiche.csv'); const Z = Object.fromEntries(zus.map((z) => [z.kombination, z])); const [V, P, U, F, G, C] = ['vanilla-aikar', 'paper-aikar', 'purpur-aikar', 'fabric-lithium-aikar', 'paper-g1-standard', 'paper-zgc-generational'].map((k) => Z[k]); const sp = (z) => (z.kapazitaet === z.kapazitaet_max ? `${z.kapazitaet}` : `${z.kapazitaet} bis ${z.kapazitaet_max}`); const spT = (z) => (z.kapazitaet_tps === z.kapazitaet_tps_max ? `${z.kapazitaet_tps}` : `${z.kapazitaet_tps} bis ${z.kapazitaet_tps_max}`); const belegt = (kz, a, b) => { const x = vgl.find((v) => v.kennzahl === kz && ((v.a === a.anzeige && v.b === b.anzeige) || (v.a === b.anzeige && v.b === a.anzeige))); if (!x) throw new Error('Vergleich fehlt'); return x.unterschied_belegt === 'true'; }; // Die Textaussagen zu Unterschieden werden gegen die Regel geprüft. for (const [a, b, soll] of [[P, U, false], [P, F, true], [P, V, true], [U, F, true], [U, V, true], [F, V, true], [P, G, false], [P, C, true], [G, C, true]]) { for (const kz of ['kapazitaet_p95', 'kapazitaet_tps']) if (belegt(kz, a, b) !== soll) throw new Error(`Textaussage passt nicht: ${a.anzeige} / ${b.anzeige} / ${kz}`); } const v55 = stufen.filter((s) => s.kombination === V.kombination && s.spieler === '55').map((s) => n(s.tps)); const v55min = Math.min(...v55), v55max = Math.max(...v55); const stealMax = Math.max(...stufen.map((s) => n(s.steal_pct))), botsMax = Math.max(...stufen.map((s) => n(s.cpu_bots_pct))), verzugMax = Math.max(...stufen.map((s) => n(s.bots_verzug_p99_ms))); const aikarNiedriger = p99.filter((x) => x.aikar_niedriger === 'true').length, g1Niedriger = p99.filter((x) => x.g1_niedriger === 'true').length; // Zusätze aus den Prüfbefunden: alles aus den CSV-Dateien berechnet const kapStufe = laeufe.map((l) => stufen.find((s) => s.lauf === l.lauf && s.spieler === l.kapazitaet)); const blockMax = kapStufe.map((s) => n(s.p95_max_ms)); const blockAb50 = blockMax.filter((v) => v >= 50).length, blockHoechst = Math.max(...blockMax); const tpsStufe = laeufe.map((l) => stufen.find((s) => s.lauf === l.lauf && s.spieler === l.kapazitaet_tps)); const probeMin = tpsStufe.reduce((m, s) => (n(s.tps_min) < n(m.tps_min) ? s : m)); if (probeMin.kombination !== V.kombination || probeMin.spieler !== '50') throw new Error('Text zur niedrigsten Probe passt nicht'); const kombis = [...new Set(laeufe.map((l) => l.kombination))]; let sxy = 0, sxx = 0; for (const k of kombis) { const a = laeufe.filter((l) => l.kombination === k).map((l) => [n(l.reihenfolge), n(l.p95_bei_50_ms)]); const mx = a.reduce((t, x) => t + x[0], 0) / a.length, my = a.reduce((t, x) => t + x[1], 0) / a.length; for (const [x, y] of a) { sxy += (x - mx) * (y - my); sxx += (x - mx) ** 2; } } const drift = sxy / sxx; if (blockAb50 !== 13 || de(blockHoechst, 1) !== '54,2' || de(probeMin.tps_min, 2) !== '17,62' || de(drift, 2) !== '0,11') throw new Error('Zusatzzahlen weichen von den Befunden ab'); const gueltig = laeufe.filter((l) => l.gueltig === 'true').length; if (gueltig !== 18 || laeufe.length !== 18) throw new Error('Es werden 18 gültige Läufe erwartet'); // Fest formulierte Textstellen gegen die Daten prüfen if (stufen.length !== 206 || liesCsv('proben.csv').length !== 4944) throw new Error('Stufen- oder Probenzahl weicht vom Text ab'); if (laeufe.filter((l) => l.kombination === P.kombination && n(l.kapazitaet) === n(P.kapazitaet_max)).length !== 1) throw new Error('Text zu Paper: genau ein Lauf am Höchstwert erwartet'); for (const z of [P, U, F, G, C]) if (z.kapazitaet !== z.kapazitaet_tps) throw new Error('Text zu den Kleinstwerten passt nicht: ' + z.anzeige); if (V.kapazitaet === V.kapazitaet_tps) throw new Error('Text zu Vanilla passt nicht'); if (!zus.every((z) => n(z.kapazitaet_tps) >= 50) || n(V.kapazitaet_tps) !== 50) throw new Error('Text zur Vergleichsstufe 50 passt nicht'); const lauf = (k, feld, rechnung, ergebnis, extra = {}) => ({ datei: 'laeufe.csv', feld, wo: { kombination: k }, rechnung, nachkomma: 0, ergebnis: n(ergebnis), ...extra }); const kern = [ { wert: `${P.kapazitaet} Bots`, titel: 'Paper mit Aikar-Flags', text: `Paper blieb im Mittel des Messfensters in allen drei Wiederholungen bis ${P.kapazitaet} Bots unter der vorab festgelegten Grenze von 50 ms p95-MSPT, in einer davon bis ${P.kapazitaet_max}. Mit im Mittel mindestens 19,5 TPS als strengerer Grenze waren es in allen drei Wiederholungen ${P.kapazitaet_tps}.`, belege: [lauf(P.kombination, 'kapazitaet', 'min', P.kapazitaet), lauf(P.kombination, 'kapazitaet', 'max', P.kapazitaet_max), lauf(P.kombination, 'kapazitaet_tps', 'min', P.kapazitaet_tps), { quelle: 1 }] }, { wert: `${U.kapazitaet} Bots`, titel: 'Purpur, bei der Kapazität von Paper nicht zu trennen', text: `Purpur erreichte ${sp(U)} Bots. Die Spanne überlappt mit der von Paper (${sp(P)}), deshalb weist diese Messung keinen Unterschied zwischen beiden aus.`, belege: [lauf(U.kombination, 'kapazitaet', 'min', U.kapazitaet), lauf(U.kombination, 'kapazitaet', 'max', U.kapazitaet_max)] }, { wert: `${F.kapazitaet} Bots`, titel: 'Fabric mit Lithium', text: `Fabric mit Lithium erreichte ${sp(F)} Bots. Das liegt über Vanilla und unter Paper und Purpur, die Spannen überlappen in beiden Richtungen nicht.`, belege: [lauf(F.kombination, 'kapazitaet', 'min', F.kapazitaet), lauf(F.kombination, 'kapazitaet', 'max', F.kapazitaet_max)] }, { wert: `${V.kapazitaet} Bots`, titel: 'Vanilla', text: `Vanilla blieb im Mittel des Messfensters in allen drei Wiederholungen bis ${V.kapazitaet} Bots unter 50 ms p95-MSPT. Mit im Mittel des Messfensters mindestens 19,5 TPS waren es nur ${V.kapazitaet_tps}.`, belege: [lauf(V.kombination, 'kapazitaet', 'min', V.kapazitaet), lauf(V.kombination, 'kapazitaet_tps', 'min', V.kapazitaet_tps)] }, { wert: `${de(v55min, 2)} TPS`, titel: 'Die MSPT-Grenze allein reicht nicht', text: `Bei 55 Bots lag Vanilla im Mittel des Messfensters unter 50 ms p95-MSPT, lief aber nur mit ${de(v55min, 2)} bis ${de(v55max, 2)} statt 20 Ticks je Sekunde. Darum nennt diese Studie neben der vorab festgelegten Kapazität auch die Kapazität bei mindestens 19,5 TPS.`, belege: [{ datei: 'daten.csv', feld: 'tps', wo: { kombination: V.kombination, spieler: '55' }, rechnung: 'min', nachkomma: 2, ergebnis: v55min }, { datei: 'daten.csv', feld: 'tps', wo: { kombination: V.kombination, spieler: '55' }, rechnung: 'max', nachkomma: 2, ergebnis: v55max }, { quelle: 2 }] }, { wert: `${G.kapazitaet} Bots`, titel: 'Standard-G1 und Aikar-Flags: kein belegter Kapazitätsunterschied', text: `Paper mit Standard-G1 erreichte ${sp(G)} Bots, mit Aikar-Flags ebenfalls ${sp(P)}. Bei der Kapazität gibt es keinen belegten Unterschied. Ergänzend beobachtet: Beim p99-Wert lagen die Aikar-Flags in ${aikarNiedriger} von ${p99.length} gemeinsamen Stufen getrennt niedriger, Standard-G1 in ${g1Niedriger === 0 ? 'keiner' : g1Niedriger}. Die Aikar-Läufe lagen im Mittel früher in der Reihenfolge, ein Teil des Abstands kann daher aus der Drift über die Messnacht stammen (siehe Grenzen).`, belege: [lauf(G.kombination, 'kapazitaet', 'min', G.kapazitaet), lauf(G.kombination, 'kapazitaet', 'max', G.kapazitaet_max), { datei: 'p99-aikar-g1.csv', feld: 'spieler', wo: { aikar_niedriger: 'true' }, rechnung: 'anzahl', nachkomma: 0, ergebnis: aikarNiedriger }, { quelle: 1 }] }, { wert: `${C.kapazitaet} Bots`, titel: 'Generational ZGC lag niedriger', text: `Paper mit Generational ZGC erreichte in allen drei Wiederholungen ${C.kapazitaet} Bots und damit weniger als mit Standard-G1 oder Aikar-Flags (je ${sp(P)}). Das gilt für dieses Lastprofil, diesen Heap und diese Java-Version.`, belege: [lauf(C.kombination, 'kapazitaet', 'min', C.kapazitaet), lauf(C.kombination, 'kapazitaet', 'max', C.kapazitaet_max), { quelle: 3 }] }, { wert: `${gueltig} von ${laeufe.length} Läufen`, titel: 'Alle Läufe gültig', text: `Alle ${laeufe.length} Läufe erfüllten die vorab festgelegten Regeln. Im Mittel einer Stufe erreichte der CPU-Steal höchstens ${de(stealMax, 3)} %, die Kerne des Lastgenerators höchstens ${de(botsMax, 2)} %.`, belege: [{ datei: 'laeufe.csv', feld: 'lauf', wo: { gueltig: 'true' }, rechnung: 'anzahl', nachkomma: 0, ergebnis: gueltig }, { datei: 'daten.csv', feld: 'steal_pct', rechnung: 'max', nachkomma: 3, ergebnis: stealMax }, { datei: 'daten.csv', feld: 'cpu_bots_pct', rechnung: 'max', nachkomma: 2, ergebnis: botsMax }] }, ]; const felder = [ ['lauf', 'Text', '', 'Kennung des Messlaufs mit Position in der zufälligen Reihenfolge'], ['kombination', 'Text', '', 'Kennung aus Programm und JVM-Profil'], ['anzeige', 'Text', '', 'Lesbarer Name der Kombination'], ['programm', 'Text', '', 'Server-Programm'], ['jvm', 'Text', '', 'JVM-Profil'], ['wiederholung', 'Zahl', '', 'Nummer der Wiederholung, 1 bis 3'], ['versuch', 'Zahl', '', 'Versuch innerhalb der Wiederholung, 1 ist der erste'], ['reihenfolge', 'Zahl', '', 'Position in der festgelegten zufälligen Reihenfolge'], ['gueltig', 'Ja/Nein', '', 'Lauf erfüllt alle vorab festgelegten Gültigkeitsregeln'], ['lauf_gueltig', 'Ja/Nein', '', 'Der zugehörige Lauf ist gültig'], ['spieler', 'Zahl', 'Bots', 'Zielzahl der Bots in dieser Stufe'], ['spieler_min', 'Zahl', 'Bots', 'Kleinste im Messfenster per Spielerliste bestätigte Botzahl'], ['spieler_verbunden', 'Zahl', 'Bots', 'Per Spielerliste bestätigte Botzahl in dieser Probe'], ['unter_grenze', 'Ja/Nein', '', 'p95-MSPT im Mittel des Messfensters unter 50 ms und alle Bots verbunden'], ['p50_ms', 'Zahl', 'ms', 'Median der Tickzeit; in Stufen Mittelwert der 100-Tick-Blöcke'], ['p95_ms', 'Zahl', 'ms', '95. Perzentil der Tickzeit; in Stufen Mittelwert der 100-Tick-Blöcke'], ['p95_max_ms', 'Zahl', 'ms', 'Höchster p95-Wert eines 100-Tick-Blocks im Messfenster'], ['p99_ms', 'Zahl', 'ms', '99. Perzentil der Tickzeit; in Stufen Mittelwert der 100-Tick-Blöcke'], ['mspt_mittel_ms', 'Zahl', 'ms', 'Mittlere Tickzeit laut /tick query'], ['tps', 'Zahl', 'Ticks/s', 'Tatsächliche Taktrate aus dem Fortschritt der Spielzeit; in Stufen Mittelwert des Messfensters'], ['tps_min', 'Zahl', 'Ticks/s', 'Niedrigste Taktrate einer 5-Sekunden-Probe im Messfenster'], ['ram_gb', 'Zahl', 'GiB', 'Belegter Arbeitsspeicher des Java-Prozesses (RSS)'], ['cpu_server_pct', 'Zahl', '%', 'Mittlere Auslastung der vier Server-Kerne'], ['cpu_bots_pct', 'Zahl', '%', 'Mittlere Auslastung der drei Kerne des Lastgenerators'], ['steal_pct', 'Zahl', '%', 'CPU-Steal über alle acht Kerne'], ['bots_verzug_p99_ms', 'Zahl', 'ms', 'Höchster p99-Verzug der Zeitgeber im Lastgenerator'], ['getrennt', 'Zahl', 'Bots', 'Bis zu dieser Stufe unerwartet getrennte Bots'], ['proben', 'Zahl', '', 'Zahl der 5-Sekunden-Proben im Messfenster'], ['zeit_unix', 'Zahl', 's', 'Zeitpunkt der Probe als Unix-Zeit'], ['erste_ueberlast', 'Zahl', 'Bots', 'Erste Stufe, deren mittlere p95-MSPT über der Grenze von 50 ms liegt'], ['kapazitaet', 'Zahl', 'Bots', 'Vorab festgelegte Kapazität; in der Zusammenfassung kleinster Wert der drei Läufe'], ['tps_bei_kapazitaet', 'Zahl', 'Ticks/s', 'Mittlere Taktrate in der Stufe der Kapazität'], ['kapazitaet_tps', 'Zahl', 'Bots', 'Höchste Stufe, bis zu der alle Stufen im Mittel des Messfensters mindestens 19,5 TPS hielten; in der Zusammenfassung kleinster Wert'], ['kapazitaet_tps_190', 'Zahl', 'Bots', 'Wie kapazitaet_tps, mit 19,0 TPS als Grenze'], ['kapazitaet_tps_198', 'Zahl', 'Bots', 'Wie kapazitaet_tps, mit 19,8 TPS als Grenze'], ['p95_bei_50_ms', 'Zahl', 'ms', 'p95-MSPT in der Stufe mit 50 Bots'], ['p99_bei_50_ms', 'Zahl', 'ms', 'p99-MSPT in der Stufe mit 50 Bots'], ['tps_bei_50', 'Zahl', 'Ticks/s', 'Taktrate in der Stufe mit 50 Bots'], ['stufen_gemessen', 'Zahl', '', 'Zahl der gemessenen Stufen des Laufs'], ['ungueltig_grund', 'Text', '', 'Grund bei ungültigen Läufen, sonst leer'], ['im_programmvergleich', 'Ja/Nein', '', 'Kombination gehört zum Vergleich der Programme'], ['im_jvm_vergleich', 'Ja/Nein', '', 'Kombination gehört zum Vergleich der JVM-Profile'], ['laeufe_gueltig', 'Zahl', '', 'Gültige Läufe der Kombination'], ['laeufe_ungueltig', 'Zahl', '', 'Ungültige Läufe der Kombination'], ['kapazitaet_median', 'Zahl', 'Bots', 'Median der Kapazität über die Läufe'], ['kapazitaet_max', 'Zahl', 'Bots', 'Größter Kapazitätswert der Läufe'], ['kapazitaet_tps_median', 'Zahl', 'Bots', 'Median von kapazitaet_tps'], ['kapazitaet_tps_max', 'Zahl', 'Bots', 'Größter Wert von kapazitaet_tps'], ['tps_bei_kapazitaet_min', 'Zahl', 'Ticks/s', 'Niedrigste Taktrate an der Kapazität über die Läufe'], ['p95_bei_50_min_ms', 'Zahl', 'ms', 'Kleinster p95-Wert bei 50 Bots'], ['p95_bei_50_max_ms', 'Zahl', 'ms', 'Größter p95-Wert bei 50 Bots'], ['p99_bei_50_min_ms', 'Zahl', 'ms', 'Kleinster p99-Wert bei 50 Bots'], ['p99_bei_50_max_ms', 'Zahl', 'ms', 'Größter p99-Wert bei 50 Bots'], ['ram_bei_50_gb', 'Zahl', 'GiB', 'Mittlerer RSS bei 50 Bots'], ['cpu_bei_50_pct', 'Zahl', '%', 'Mittlere Auslastung der Server-Kerne bei 50 Bots'], ['vergleich', 'Text', '', 'Programmvergleich oder JVM-Vergleich'], ['kennzahl', 'Text', '', 'Verglichene Kennzahl'], ['regel', 'Text', '', 'Ob die Kennzahl vorab festgelegt oder nachträglich ergänzt wurde'], ['a', 'Text', '', 'Erste Kombination'], ['a_min', 'Zahl', '', 'Kleinster Wert der ersten Kombination'], ['a_max', 'Zahl', '', 'Größter Wert der ersten Kombination'], ['b', 'Text', '', 'Zweite Kombination'], ['b_min', 'Zahl', '', 'Kleinster Wert der zweiten Kombination'], ['b_max', 'Zahl', '', 'Größter Wert der zweiten Kombination'], ['unterschied_belegt', 'Ja/Nein', '', 'Die Spannen der Wiederholungen überlappen sich nicht'], ['besser', 'Text', '', 'Kombination mit dem günstigeren Wert, nur bei belegtem Unterschied'], ['aikar_min', 'Zahl', 'ms', 'Kleinster p99-Wert mit Aikar-Flags in der Stufe'], ['aikar_max', 'Zahl', 'ms', 'Größter p99-Wert mit Aikar-Flags in der Stufe'], ['g1_min', 'Zahl', 'ms', 'Kleinster p99-Wert mit Standard-G1 in der Stufe'], ['g1_max', 'Zahl', 'ms', 'Größter p99-Wert mit Standard-G1 in der Stufe'], ['aikar_niedriger', 'Ja/Nein', '', 'Alle drei Aikar-Werte liegen unter allen drei G1-Werten'], ['g1_niedriger', 'Ja/Nein', '', 'Alle drei G1-Werte liegen unter allen drei Aikar-Werten'], ].map(([name, typ, einheit, beschreibung]) => ({ name, typ, ...(einheit ? { einheit } : {}), beschreibung })); const skripte = [ ['01-einrichten.sh', 'Einrichtung', 'Lädt Java und die Server-Programme und prüft die Prüfsummen.'], ['02-vorlagen.py', 'Welt und Vorlagen', 'Erzeugt die gemeinsame Welt und je Programm eine Vorlage.'], ['03-plan.py', 'Messplan', 'Legt Matrix, Reihenfolge und Regeln vor der Messung fest.'], ['gemeinsam.py', 'Gemeinsame Teile', 'Festwerte, JVM-Profile, RCON auf Loopback, Start und Stopp.'], ['messlauf.py', 'Messlauf', 'Führt einen Lauf aus und schreibt Proben und Stufen.'], ['hauptlauf.py', 'Hauptmessung', 'Arbeitet die Reihenfolge ab und bewertet die Gültigkeit.'], ['bots.mjs', 'Lastgenerator', 'Protokoll-Clients mit festem Seed und Bewegungsprofil.'], ['welt-pruefen.py', 'Weltprüfung', 'Zählt die vollständig erzeugten Chunks.'], ['auswertung.mjs', 'Auswertung', 'Berechnet alle Tabellen aus den Rohdaten.'], ['baue-studie.mjs', 'Studienbau', 'Erzeugt diese Studiendatei aus den Tabellen.'], ].map(([datei, titel, beschreibung]) => ({ datei, art: 'skript', titel, beschreibung, sha256: '' })); const kurz = `${laeufe.length} Läufe mit Protokoll-Bots auf einer Test-VM: Paper ${P.kapazitaet}, Purpur ${U.kapazitaet}, Fabric mit Lithium ${F.kapazitaet}, Vanilla ${V.kapazitaet} (bei 19,5 TPS: ${V.kapazitaet_tps}). An Paper lag Generational ZGC unter G1.`; if (kurz.length > 165) throw new Error('Kurzfassung zu lang: ' + kurz.length); const studie = { format: 1, slug: 'server-haertetest-minecraft', status: 'entwurf', kategorie: 'gameserver', art: 'eigene-messung', marken_hinweis: 'minecraft', titel: 'Server-Härtetest: Wie viele Protokoll-Bots tragen Vanilla, Paper, Purpur und Fabric mit Lithium?', untertitel: 'Vier Server-Programme für Minecraft und drei JVM-Profile, gemessen mit Protokoll-Bots auf einer Test-VM', kurzfassung: kurz, fragestellung: 'Wie viele gleichzeitige Protokoll-Bots schaffen Vanilla, Paper, Purpur und Fabric mit Lithium bei gleicher Hardware, und wie stark beeinflussen JVM-Einstellungen das Ergebnis?', schlagwoerter: ['Minecraft-Server', 'Paper', 'Purpur', 'Fabric', 'Lithium', 'Vanilla', 'MSPT', 'TPS', 'Aikar-Flags', 'G1', 'ZGC', 'Lasttest'], version: '1.0.0', stand: '2026-11-22', erstveroeffentlichung: null, naechste_aktualisierung: null, vorlaeufig: false, zeitraum: { von: '2026-11-21', bis: '2026-11-22' }, stichprobe: { umfang: laeufe.length, ausgewertet: gueltig, einheit: 'Messläufe', auswahl: 'Sechs Kombinationen aus Programm und JVM-Profil mit je drei Wiederholungen, in einer vorab festgelegten zufälligen Reihenfolge.' }, autoren: [{ name: 'Erik Friedl', typ: 'person', orcid: '0009-0008-2784-4314' }, { name: 'Nexthosting', typ: 'organisation' }], autoren_freigegeben: false, lizenz: { kennung: 'CC-BY-4.0', name: 'CC BY 4.0', url: 'https://creativecommons.org/licenses/by/4.0/deed.de' }, anbieternamen: false, eigeninteresse: 'Nexthosting verkauft selbst Gameserver, darunter Server für Minecraft, und hat deshalb ein wirtschaftliches Interesse an diesem Thema. Keines der getesteten Programme stammt von Nexthosting. Die Messung lief auf einer von Nexthosting bestellten Test-VM. Die Studie bewertet keine Angebote von Hostern. Verantwortlich für diese Studie ist Nexthosting, Kontakt: support@nexthosting.net.', kernergebnisse: kern, zusammenfassung: [ `Wir haben Vanilla, Paper, Purpur und Fabric mit Lithium in Minecraft 26.3 auf derselben virtuellen Maschine belastet. Protokoll-Bots traten stufenweise bei, bis der Server überlastet war. Alle ${laeufe.length} Läufe waren nach den vorab festgelegten Regeln gültig.`, `Als Kapazität zählt die höchste Botzahl, bis zu der die p95-Tickzeit im Mittel des Messfensters unter 50 ms blieb, und zwar in allen drei Wiederholungen. Paper erreichte ${P.kapazitaet}, Purpur ${U.kapazitaet}, Fabric mit Lithium ${F.kapazitaet} und Vanilla ${V.kapazitaet} Bots. Paper und Purpur lassen sich bei der vorab festgelegten Kapazität nicht voneinander trennen, bei allen anderen Programmpaaren überlappen sich die Spannen der Wiederholungen nicht.`, `Bei den JVM-Einstellungen zeigte sich an Paper kein belegter Kapazitätsunterschied zwischen Standard-G1 und den Aikar-Flags. Generational ZGC lag mit ${C.kapazitaet} Bots darunter.`, `Die Tickzeit allein zeigt nicht jede Überlast: Vanilla blieb bei 55 Bots im Mittel unter 50 ms p95, erreichte aber nur ${de(v55min, 2)} bis ${de(v55max, 2)} statt 20 Ticks je Sekunde. Deshalb steht neben jeder Kapazität auch der Wert bei im Mittel mindestens 19,5 TPS. Die Zahlen gelten für diese VM und dieses Bot-Profil und lassen sich nicht direkt auf echte Spieler übertragen.`, ], methode: { schritte: [ { titel: 'Programme festhalten', text: 'Alle Programme liefen auf Minecraft 26.3. Java, Server-Programme und Lithium wurden mit der veröffentlichten Prüfsumme geprüft. Für den Fabric-Starter gibt es keine veröffentlichte Prüfsumme, dort ist der eigene SHA-256-Wert festgehalten. Die server.properties waren für alle Programme gleich, die übrigen Einstellungen blieben auf den Standardwerten des jeweiligen Programms. Die einzige weitere Änderung betrifft Paper und Purpur: Die Verbindungsdrossel je IP-Adresse wurde abgeschaltet, weil alle Bots von derselben Loopback-Adresse kommen. Lithium beschreibt sich als Optimierungs-Mod, der die Spielmechanik nicht verändern soll (Quelle 4), Purpur als direkten Ersatz für Paper (Quelle 5).' }, { titel: 'Eine gemeinsame Welt', text: 'Der unveränderte Vanilla-Server erzeugte mit Seed 20261121 einmal eine Welt mit 31.329 vollständig generierten Chunks. Jeder Lauf startete von einer frischen Kopie dieser Welt.' }, { titel: 'Getrennte Kerne', text: 'Der Server lief fest auf den Kernen 0 bis 3, der Lastgenerator auf den Kernen 4 bis 6. Das Messskript war nicht an einen Kern gebunden. Während der Messung wurden die Rohdaten alle 15 Minuten mit niedrigster Priorität auf Kern 7 gepackt. Der Eintrag messung: 7 in plan.json wurde nicht als Kernbindung umgesetzt. Server und RCON waren nur auf der Loopback-Adresse erreichbar, online-mode=false war nur in diesem isolierten Aufbau gesetzt. Die Minecraft-EULA hat Erik Friedl für diese Testserver freigegeben.' }, { titel: 'Protokoll-Bots', text: 'Ein eigener schlanker Client spricht das echte Netzwerkprotokoll von Version 26.3: Anmeldung, Konfiguration, Spielphase, Keep-Alive und Teleport-Bestätigungen. Chunk-Bestätigungen sendet der Client, wenn er eine Chunk-Batch-Meldung erkennt. Das war bei Vanilla und Fabric der Fall, bei Paper und Purpur zählte er in keinem Lauf eine solche Meldung. Die von mineflayer genutzte Protokolldatenbank führte Version 26.3 zum Messzeitpunkt noch nicht. Jeder Bot hat einen festen Seed, sendet mit einem Soll-Takt von 20 Positionspaketen je Sekunde und bewegt sich in Gehgeschwindigkeit (0,2158 Blöcke je Takt) zwischen zufälligen Wegpunkten. Je sechs Bots bilden eine Gruppe, die Gruppen liegen 256 Blöcke auseinander. Die Bots fliegen im Kreativmodus auf Höhe 120.' }, { titel: 'Stufen und Messfenster', text: 'Die Stufen waren 20, 30 und 40 Bots, danach in Fünferschritten. Nach dem Beitritt folgten 60 Sekunden Einschwingzeit und 120 Sekunden Messfenster mit einer Probe alle 5 Sekunden. Ein Lauf endete nach zwei Stufen über der Grenze oder unter 15 TPS.' }, { titel: 'Messgrößen', text: 'MSPT p50, p95 und p99 kamen bei allen Programmen aus dem Befehl /tick query über RCON, der die letzten 100 Ticks auswertet. Der Stufenwert ist der Mittelwert dieser Blöcke im Messfenster. Die TPS wurden aus dem Fortschritt der Spielzeit berechnet. Dazu kamen RAM des Java-Prozesses, CPU je Kerngruppe, CPU-Steal und die per Spielerliste bestätigte Botzahl.' }, { titel: 'Vorläufe vor dem Plan', text: 'Vor der Festlegung des Plans liefen zwei Pilotläufe (Paper, Vanilla) und kurze Probeläufe aller Kombinationen. Danach wurden Stufenraster und Messzeiten festgelegt, die Grenze von 50 ms stand schon vorher. Die Vorläufe fließen nicht in die Auswertung ein.' }, { titel: 'Gültigkeit', text: 'Vorab festgelegt: CPU-Steal unter 2 %, Lastgenerator unter 70 % CPU und unter 20 ms Zeitgeber-Verzug (p99), vollständige Proben, alle Bots verbunden, solange der Server nicht überlastet ist, und zwei Stichproben-Bots bewegen sich im Messfenster nachweisbar. Ungültige Läufe wären wiederholt worden, es gab keine.' }, { titel: 'Kapazität und Unterschiede', text: 'Vorab festgelegt: Die Kapazität eines Laufs ist die höchste Stufe, bis zu der alle Stufen im Mittel des Messfensters unter 50 ms p95-MSPT bleiben und alle Bots verbunden sind. Die Kapazität einer Kombination ist der kleinste Wert ihrer drei Läufe. Ein Unterschied gilt nur, wenn sich die Spannen der Wiederholungen nicht überlappen.' }, { titel: 'Nachträgliche Ergänzung', text: 'Nach der Messung zeigte sich, dass die Taktrate teils schon unter 20 TPS fiel, während die p95-Tickzeit im Mittel noch unter 50 ms lag. Darum wurden zusätzlich die Kapazität bei mindestens 19,5 TPS und die Kennzahlen bei 50 Bots ausgewertet. Die Stufe 50 ist die höchste, in der alle Kombinationen im Mittel des Messfensters noch mindestens 19,5 TPS erreichten. Diese Auswertungen waren nicht vorab festgelegt und sind in den Daten so gekennzeichnet.' }, ], aufbau: [ { name: 'Spielversion', wert: 'Minecraft 26.3 (Protokoll 777)' }, { name: 'Vanilla', wert: '26.3' }, { name: 'Paper', wert: '26.3, Build 257' }, { name: 'Purpur', wert: '26.3, Build 2660' }, { name: 'Fabric', wert: 'Loader 0.20.1, Installer 1.1.2' }, { name: 'Lithium', wert: '0.26.4 für 26.3' }, { name: 'Java', wert: 'Temurin 25.0.5.1+2' }, { name: 'Heap', wert: '10 GB (Xms gleich Xmx)' }, { name: 'JVM-Profil Standard-G1', wert: '-XX:+UseG1GC' }, { name: 'JVM-Profil Aikar-Flags', wert: 'Flags laut PaperMC-Dokumentation' }, { name: 'JVM-Profil Generational ZGC', wert: '-XX:+UseZGC' }, { name: 'Virtuelle Maschine', wert: '8 vCPU unter KVM, 31,3 GiB RAM, 100 GiB virtuelle Festplatte, Debian 12' }, { name: 'Gemeldete CPU', wert: 'QEMU Virtual CPU, AuthenticAMD; das physische Modell ist aus der VM nicht feststellbar' }, { name: 'Kerne', wert: 'Server 0 bis 3, Bots 4 bis 6, Sicherung 7, Messskript ungebunden' }, { name: 'Sichtweite', wert: '10 Chunks, Simulationsweite 10 Chunks' }, { name: 'Spielmodus', wert: 'Kreativ, Schwierigkeit normal' }, { name: 'Messzeitraum', wert: '21.11.2026, 20:12 UTC bis 22.11.2026, 06:59 UTC' }, ], }, grenzen: [ { titel: 'Bots sind keine Spieler', text: 'Die Bots fliegen, bauen nicht, kämpfen nicht, chatten nicht, nutzen kein Inventar und lösen keine Redstone-Schaltungen aus. Echte Spieler erzeugen eine andere Last. Die absoluten Botzahlen lassen sich deshalb nicht auf einen echten Server übertragen. Die Welt war vorab erzeugt und die Bots verließen diesen Bereich nicht. Die Last durch das Erzeugen neuer Chunks ist deshalb nicht enthalten.' }, { titel: 'Eine VM', text: 'Gemessen wurde auf einer einzigen virtuellen Maschine mit vier Kernen für den Server. Auf anderer Hardware fallen die Werte anders aus, auch die Abstände zwischen den Programmen können sich ändern.' }, { titel: 'Ein Testprofil', text: 'Es gab eine Welt, einen Seed, ein Bewegungsprofil und außer Lithium keine Mods oder Plugins. Die Programme wurden nicht einzeln optimiert. Mit angepasster Konfiguration oder anderer Last kann die Reihenfolge anders aussehen. Der Tag-Nacht-Wechsel lief mit. Weil alle Läufe demselben Zeitplan folgen, fallen bestimmte Stufen immer in die Nacht. Der Einfluss wurde in dieser Messung nicht getrennt erfasst.' }, { titel: 'Unterschiedliche Standardkonfiguration', text: 'Die Standardkonfiguration von Paper und Purpur enthält die Einstellung entity-activation-range (Tiere und Monster 32 Blöcke), die in den Vorlagen von Vanilla und Fabric fehlt. Ob alle Programme dieselbe Simulationsarbeit gerechnet haben, wurde nicht geprüft, Entitätenzahlen wurden nicht erfasst.' }, { titel: 'MSPT und TPS weichen ab', text: `Bei Vanilla lag die p95-Tickzeit bei 55 Bots im Mittel des Messfensters unter 50 ms, die Taktrate aber bei ${de(v55min, 2)} bis ${de(v55max, 2)} TPS. Die Ursache wurde nicht untersucht. Bei Vanilla liegt die vorab festgelegte Kapazität deshalb ${n(V.kapazitaet) - n(V.kapazitaet_tps)} Bots über dem Wert bei mindestens 19,5 TPS. Bei den fünf anderen Kombinationen stimmen beide Kleinstwerte überein.` }, { titel: 'Mittelwerte statt Einzelwerte', text: `Die Grenze von 50 ms gilt für den Mittelwert der 100-Tick-Blöcke im Messfenster. In ${blockAb50} von ${laeufe.length} Läufen lag in der Kapazitätsstufe mindestens ein einzelner Block bei 50 ms oder darüber, höchstens bei ${de(blockHoechst, 1)} ms. Auch die Grenze von 19,5 TPS gilt für den Mittelwert des Messfensters. In den Stufen der Kapazität bei mindestens 19,5 TPS lagen einzelne 5-Sekunden-Proben darunter, am niedrigsten bei ${de(probeMin.tps_min, 2)} TPS (Vanilla, 50 Bots).` }, { titel: 'Drift über die Messnacht', text: `Bei gleicher Botzahl stieg die p95-Tickzeit mit der Position in der Laufreihenfolge, bei 50 Bots um rund ${de(drift, 2)} ms je Lauf (nachträglich ausgewertet). Die Ursache wurde in dieser Messung nicht untersucht. Die Reihenfolge war zufällig, aber nicht in Blöcken ausgeglichen, deshalb enthält die Streuung der Wiederholungen auch diesen Effekt.` }, { titel: 'Nachträgliche Kennzahlen', text: 'Die Kapazität bei mindestens 19,5 TPS, die Vergleichsstufe mit 50 Bots und der p99-Vergleich zwischen Aikar-Flags und Standard-G1 wurden erst nach Sicht auf die Daten gewählt. Sie sind ergänzende Beobachtungen und keine vorab festgelegten Prüfungen.' }, { titel: 'Grobes Raster, drei Wiederholungen', text: 'Die Stufen liegen im relevanten Bereich fünf Bots auseinander, kleinere Unterschiede sind nicht messbar. Drei Wiederholungen je Kombination zeigen die Streuung nur grob. Ein statistischer Test wurde nicht gerechnet.' }, { titel: 'RAM-Werte nicht vergleichbar', text: 'Die Aikar-Flags enthalten AlwaysPreTouch, das den Speicher schon beim Start reserviert (Quelle 1). Der gemessene Arbeitsspeicher hängt deshalb an der JVM-Einstellung und zeigt nicht den Bedarf des Programms. Diese Studie trifft keine Aussage darüber, welches Programm weniger RAM braucht.' }, { titel: 'JVM-Vergleich nur an Paper', text: 'Die drei JVM-Profile wurden nur mit Paper, einem Heap von 10 GB und Java 25 gemessen. Der Programmvergleich lief nur mit Aikar-Flags. Beide Ergebnisse lassen sich nicht ohne Weiteres auf andere Kombinationen übertragen.' }, { titel: 'Momentaufnahme', text: 'Die Ergebnisse gelten für die genannten Versionen und Builds. Spätere Versionen können sich anders verhalten.' }, ], ergebnisse: [ { typ: 'text', titel: 'So liest man die Ergebnisse', absaetze: ['Die vorab festgelegte Kapazität beruht auf der p95-Tickzeit. Die zweite Kapazität verlangt stattdessen, dass der Server im Mittel des Messfensters mindestens 19,5 von 20 Ticks je Sekunde schafft und alle Bots verbunden bleiben. Beide nennen den kleinsten Wert aus drei Wiederholungen. Ein Unterschied zählt nur, wenn sich die Spannen der Wiederholungen nicht überlappen.'] }, { typ: 'balken', titel: 'Kapazität der Programme', beschreibung: 'Höchste Botzahl mit im Mittel des Messfensters unter 50 ms p95-MSPT in allen drei Wiederholungen, alle mit Aikar-Flags.', datei: 'zusammenfassung.csv', wo: { im_programmvergleich: 'true' }, beschriftung: 'anzeige', wert: 'kapazitaet', nachkomma: 0, einheit: 'Bots' }, { typ: 'balken', titel: 'Kapazität der Programme bei mindestens 19,5 TPS', beschreibung: 'Nachträglich ergänzt: höchste Botzahl mit im Mittel mindestens 19,5 TPS in allen drei Wiederholungen.', datei: 'zusammenfassung.csv', wo: { im_programmvergleich: 'true' }, beschriftung: 'anzeige', wert: 'kapazitaet_tps', nachkomma: 0, einheit: 'Bots' }, { typ: 'balken', titel: 'Kapazität von Paper je JVM-Profil', beschreibung: 'Höchste Botzahl mit im Mittel des Messfensters unter 50 ms p95-MSPT in allen drei Wiederholungen.', datei: 'zusammenfassung.csv', wo: { im_jvm_vergleich: 'true' }, beschriftung: 'anzeige', wert: 'kapazitaet', nachkomma: 0, einheit: 'Bots' }, { typ: 'streuung', titel: 'p95-Tickzeit je Stufe', beschreibung: 'Jeder Punkt ist eine Stufe eines Laufs, dargestellt als Mittelwert des Messfensters. Die Grenze von 50 ms gilt für diesen Mittelwert.', datei: 'daten.csv', name: 'lauf', x: { feld: 'spieler', titel: 'Bots' }, y: { feld: 'p95_ms', titel: 'p95-MSPT (ms)' }, gruppe: 'anzeige' }, { typ: 'streuung', titel: 'Tatsächliche Taktrate je Stufe', beschreibung: 'Jeder Punkt ist eine Stufe eines Laufs. Das Ziel sind 20 Ticks je Sekunde.', datei: 'daten.csv', name: 'lauf', x: { feld: 'spieler', titel: 'Bots' }, y: { feld: 'tps', titel: 'TPS' }, gruppe: 'anzeige' }, { typ: 'tabelle', titel: 'Alle Kombinationen', datei: 'zusammenfassung.csv', sortierung: { feld: 'kapazitaet', richtung: 'absteigend' }, spalten: [ { feld: 'anzeige', titel: 'Kombination', kopf: true }, { feld: 'kapazitaet', titel: 'Kapazität', format: 'zahl' }, { feld: 'kapazitaet_max', titel: 'Höchster Lauf', format: 'zahl' }, { feld: 'kapazitaet_tps', titel: 'Bei 19,5 TPS', format: 'zahl' }, { feld: 'kapazitaet_tps_max', titel: 'Höchster Lauf (TPS)', format: 'zahl' }, { feld: 'p95_bei_50_min_ms', titel: 'p95 bei 50, min', format: 'zahl', nachkomma: 1, einheit: 'ms' }, { feld: 'p95_bei_50_max_ms', titel: 'p95 bei 50, max', format: 'zahl', nachkomma: 1, einheit: 'ms' }, { feld: 'p99_bei_50_min_ms', titel: 'p99 bei 50, min', format: 'zahl', nachkomma: 1, einheit: 'ms' }, { feld: 'p99_bei_50_max_ms', titel: 'p99 bei 50, max', format: 'zahl', nachkomma: 1, einheit: 'ms' }, ] }, { typ: 'tabelle', titel: 'Alle 18 Läufe', datei: 'laeufe.csv', sortierung: { feld: 'reihenfolge', richtung: 'aufsteigend' }, suche: true, filter: ['programm', 'jvm'], spalten: [ { feld: 'reihenfolge', titel: 'Nr.', format: 'zahl' }, { feld: 'anzeige', titel: 'Kombination', kopf: true }, { feld: 'wiederholung', titel: 'Wdh.', format: 'zahl' }, { feld: 'kapazitaet', titel: 'Kapazität', format: 'zahl' }, { feld: 'tps_bei_kapazitaet', titel: 'TPS dort', format: 'zahl', nachkomma: 2 }, { feld: 'kapazitaet_tps', titel: 'Bei 19,5 TPS', format: 'zahl' }, { feld: 'gueltig', titel: 'Gültig', format: 'janein' }, ] }, { typ: 'tabelle', titel: 'Paarvergleiche', beschreibung: 'Ein Unterschied gilt als belegt, wenn sich die Spannen der drei Wiederholungen nicht überlappen.', datei: 'vergleiche.csv', suche: true, filter: ['vergleich', 'kennzahl', 'regel'], spalten: [ { feld: 'kennzahl', titel: 'Kennzahl' }, { feld: 'a', titel: 'A', kopf: true }, { feld: 'a_min', titel: 'A min', format: 'zahl', nachkomma: 1 }, { feld: 'a_max', titel: 'A max', format: 'zahl', nachkomma: 1 }, { feld: 'b', titel: 'B' }, { feld: 'b_min', titel: 'B min', format: 'zahl', nachkomma: 1 }, { feld: 'b_max', titel: 'B max', format: 'zahl', nachkomma: 1 }, { feld: 'unterschied_belegt', titel: 'Belegt', format: 'janein' }, ] }, ], dateien: [ { datei: 'daten.csv', art: 'daten', titel: 'Messwerte je Stufe (CSV)', beschreibung: 'Alle 206 Stufen der 18 Läufe.', sha256: '' }, { datei: 'daten.json', art: 'daten', titel: 'Messwerte je Stufe (JSON)', beschreibung: 'Dieselben Daten als JSON.', sha256: '' }, { datei: 'laeufe.csv', art: 'daten', titel: 'Ergebnis je Lauf', beschreibung: 'Kapazität und Gültigkeit jedes Laufs.', sha256: '' }, { datei: 'zusammenfassung.csv', art: 'daten', titel: 'Ergebnis je Kombination', beschreibung: 'Kapazitäten und Spannen der sechs Kombinationen.', sha256: '' }, { datei: 'vergleiche.csv', art: 'daten', titel: 'Paarvergleiche', beschreibung: 'Alle Vergleiche mit der Regel für Unterschiede.', sha256: '' }, { datei: 'p99-aikar-g1.csv', art: 'daten', titel: 'p99 Aikar-Flags und Standard-G1', beschreibung: 'Ergänzender Vergleich je gemeinsamer Stufe.', sha256: '' }, { datei: 'proben.csv', art: 'daten', titel: 'Einzelproben', beschreibung: 'Alle 4.944 Proben im Abstand von 5 Sekunden.', sha256: '' }, { datei: 'plan.json', art: 'dokument', titel: 'Messplan', beschreibung: 'Vor der Hauptmessung festgelegte Matrix, Reihenfolge und Regeln.', sha256: '' }, { datei: 'messprotokoll.txt', art: 'dokument', titel: 'Messprotokoll', beschreibung: 'Start, Ende und Bewertung jedes Laufs.', sha256: '' }, { datei: 'herkunft.txt', art: 'dokument', titel: 'Herkunft der Programme', beschreibung: 'Download-Adressen und Prüfsummen.', sha256: '' }, { datei: 'liesmich.txt', art: 'dokument', titel: 'Liesmich', beschreibung: 'Überblick über die Dateien und Hinweis zur Marke.', sha256: '' }, ...skripte, ], felder, reproduzierbarkeit: 'Für eine Wiederholung braucht man eine Linux-Maschine mit acht Kernen und rund 32 GB RAM wie hier, Node.js und Python 3. Die Skripte erwarten den Arbeitsordner /root/studien/haertetest, laden Java und dieselben Programmversionen, solange diese Downloads verfügbar sind, prüfen die Prüfsummen, erzeugen die Welt und führen den Messplan aus. Seed, Reihenfolge, Stufen und Regeln stehen in plan.json. Andere Hardware, andere Builds oder eine andere Auslastung des Wirtssystems führen zu anderen absoluten Werten.', quellen: [ { nr: 1, titel: "Aikar's flags", herausgeber: 'PaperMC', jahr: '2026', url: 'https://docs.papermc.io/paper/aikars-flags/', abgerufen: '2026-11-21' }, { nr: 2, titel: 'Commands/tick', herausgeber: 'Minecraft Wiki', jahr: '2026', url: 'https://minecraft.wiki/w/Commands/tick', abgerufen: '2026-11-21' }, { nr: 3, titel: 'JEP 490: ZGC: Remove the Non-Generational Mode', herausgeber: 'OpenJDK', url: 'https://openjdk.org/jeps/490', abgerufen: '2026-11-21' }, { nr: 4, titel: 'Lithium', herausgeber: 'Lithium-Projekt auf Modrinth', jahr: '2026', url: 'https://modrinth.com/mod/lithium', abgerufen: '2026-11-21' }, { nr: 5, titel: 'Purpur Documentation', herausgeber: 'PurpurMC', url: 'https://purpurmc.org/docs/purpur/', abgerufen: '2026-11-21' }, ], aenderungen: [{ version: '1.0.0', datum: '2026-11-22', art: 'fassung', text: 'Erste Fassung.' }], begriffe_belegt: {}, }; fs.writeFileSync(path.join(ziel, 'studie.json'), JSON.stringify(studie, null, 2) + '\n'); // Begleitdateien: unveränderte Kopien aus den per Prüfsumme bestätigten Rohdaten for (const d of ['01-einrichten.sh', '02-vorlagen.py', '03-plan.py', 'gemeinsam.py', 'messlauf.py', 'hauptlauf.py', 'bots.mjs', 'welt-pruefen.py']) fs.copyFileSync(path.join(roh, 'skripte', d), path.join(ziel, d)); const hier = path.dirname(fileURLToPath(import.meta.url)); for (const d of ['auswertung.mjs', 'baue-studie.mjs']) fs.copyFileSync(path.join(hier, d), path.join(ziel, d)); fs.copyFileSync(path.join(roh, 'plan.json'), path.join(ziel, 'plan.json')); fs.copyFileSync(path.join(roh, 'protokoll.jsonl'), path.join(ziel, 'messprotokoll.txt')); fs.copyFileSync(path.join(roh, 'jars', 'herkunft.tsv'), path.join(ziel, 'herkunft.txt')); fs.writeFileSync(path.join(ziel, 'liesmich.txt'), `Server-Härtetest: Rohdaten und Skripte KEINE OFFIZIELLE MINECRAFT-VERÖFFENTLICHUNG. NICHT GENEHMIGT VON ODER VERBUNDEN MIT MOJANG ODER MICROSOFT. Verantwortlich für diese Studie ist Nexthosting. Kontakt: support@nexthosting.net Autoren: Erik Friedl, Nexthosting Lizenz für Text und Daten: CC BY 4.0, https://creativecommons.org/licenses/by/4.0/deed.de Die Lizenz gilt nicht für Minecraft und die getesteten Programme. Diese sind nicht Teil der Daten. Inhalt daten.csv, daten.json Messwerte je Stufe (206 Stufen) laeufe.csv Ergebnis je Lauf (18 Läufe) zusammenfassung.csv Ergebnis je Kombination (6 Kombinationen) vergleiche.csv Paarvergleiche mit der Regel für Unterschiede p99-aikar-g1.csv Ergänzender p99-Vergleich je Stufe proben.csv Einzelproben im Abstand von 5 Sekunden plan.json Vor der Hauptmessung festgelegter Plan messprotokoll.txt Start, Ende und Bewertung jedes Laufs (JSON je Zeile) herkunft.txt Download-Adressen und Prüfsummen (Tabulator getrennt) *.py, *.sh, *.mjs Mess- und Auswertungsskripte Wichtig beim Lesen Bots sind keine echten Spieler. Das Ergebnis gilt für diese eine VM und dieses eine Testprofil. Die Kapazität über p95-MSPT war vorab festgelegt. Die Kapazität bei mindestens 19,5 TPS und die Werte bei 50 Bots wurden nachträglich ergänzt. `); console.log('studie.json geschrieben, Kurzfassung', kurz.length, 'Zeichen');