# Performance-Messwerte

> Jeder Messwert für v1.0.0 mit seiner Quelle: der Basisbeweis eines vollständigen Ethereum-Blocks, der Rekursionsbaum, der Decider und der Contract, der Shard-Beweis jeder Familie und die Kosten von Mercury selbst.

Alle End-to-End-Zahlen beziehen sich auf Block 257.510 von `glamsterdam-devnet-8`, bewiesen über das Gastprogramm (Guest) des zustandslosen Validators: 60 Transaktionen, 101,5 Mgas, 198 Millionen Zyklen. Jede Zahl stammt aus den Messungen der Spezifikation.

## Von Anfang bis Ende

| Stufe | Maschine | Ergebnis |
| --- | --- | --- |
| Basisbeweis | 32 vCPUs, 247,7 GiB, 12 gleichzeitig bearbeitete Shards | 207 Shards, 14,5 MB, 2.481 s; Spitze 173,92 GiB |
| Rekursionsblätter | 32 CPUs, vier Blätter gleichzeitig | 21, 24, 23 und 27 Shards; 2.157 s; Spitze 92 GiB |
| Rekursionswurzel | dieselbe Maschine, vier gleichzeitig bearbeitete Shards | 21 Shards, 460 s, 1,03 MB |
| Zeremonie des Deciders | Laptop mit 18 Kernen | `init` 65 s; ein Beitrag 50–56 s; `key` 70 s und 12,7 GB; der Schlüssel 2,65 GB |
| Decider-Beweis | Laptop mit 18 Kernen | Schlüssel in 1 s eingelesen, Beweis 18,5 s, 6,1 GB; 7.896.686 Constraints über `2^23` |
| On-Chain-Verifikation | revm | 3.620.026 gas; 34.980 Byte Calldata; 358 Punkte |

## Der Basisbeweis, Durchlauf für Durchlauf

| | |
| --- | --- |
| Durchlauf 1, Commit | 191 s; im Mittel 25,7 ausgelastete vCPUs; Befüllungen auf einem einzigen Thread machen 81 % seiner Shard-Sekunden aus; per Stichprobe gemessener Speicher höchstens 15,9 GiB |
| Durchlauf 2, Beweis | 2.290 s; im Mittel 11,95 von 12 Shards gehalten und 30,4 vCPUs ausgelastet bis zum Exit des Gastprogramms; danach eine Schlussphase von 460 s, deren längste Abschnitte die Befüllungen der beiden `KECCAK_F`-Shards auf einem einzigen Thread sind, 200 s und 279 s |
| Speicherspitze | 173,92 GiB: die beiden `KECCAK_F`-Shards der Höhe `2^18`, gemeinsam in der Schlussphase, ohne dass sonst etwas in Bearbeitung war |

Die Spitze wurde durch die Höhe einer einzigen Delegationsfamilie bestimmt, nicht durch die Zahl der gleichzeitig bearbeiteten Shards.

## Ein kleines Gastprogramm

Das Gastprogramm des Schnellstarts, 114 Zyklen in vier Befehlsfamilien, bewiesen bei Befehlshöhen von `2^20` und Fensterhöhen von `2^16` mit zwei gleichzeitig bearbeiteten Shards: 7 Shards, 52 s und eine Spitze von 18 GB auf einem Laptop mit 18 Kernen und 48 GiB, fast alles davon die beiden `2^20`-Shards in Bearbeitung. Die Untergrenze eines Beweises bestimmen seine Familien und Höhen, nicht seine Zyklenzahl.

## Der Shard jeder Familie

Bei den Standardhöhen. Die Beweisgröße eines Shards ist durch Form und Höhe seines Schaltkreises festgelegt; seine Beweiskosten folgen seiner Höhe mal der Breite seines Schaltkreises, unabhängig davon, wie viele Zeilen aktiv sind.

| Familie | Höhe | Committet `M`/`W`/`S` | Constraint-Gates | Innere Spalten | Shard-Beweis |
| --- | --- | --- | --- | --- | --- |
| `ADD_SUB_LUI_AUIPC` | `2^22` | 27 / 35 / 7 | 63 | 314 | 64.764 B |
| `JUMP_BRANCH_SLT` | `2^22` | 21 / 44 / 10 | 42 | 392 | 69.436 B |
| `SHIFT_BITWISE` | `2^22` | 21 / 61 / 10 | 48 | 478 | 76.644 B |
| `MUL_DIV` | `2^20` | 21 / 54 / 9 | 54 | 444 | 67.412 B |
| `MEM_WORD` | `2^22` | 31 / 24 / 7 | 33 | 314 | 63.836 B |
| `MEM_SUBWORD` | `2^22` | 31 / 55 / 10 | 53 | 472 | 76.196 B |
| `ATOMICS` | `2^20` | 26 / 54 / 9 | 46 | 472 | 68.468 B |
| `INIT_TEARDOWN` | `2^22` | 2 / 0 / 1 | 0 | 46 | 36.316 B |
| `ZERO_WINDOWS` | `2^22` | 2 / 0 / 0 | 0 | 46 | 36.284 B |
| `KECCAK_F` | `2^18` | 208 / 1.556 / 0 | 385 | 5.490 | 381.100 B |
| `POSEIDON2` | `2^8` | 100 / 4.092 / 0 | 4.248 | 2.020 | 664.780 B |
| `FR_ARITH` | `2^8` | 104 / 2.576 / 0 | 2.701 | 142 | 266.292 B |
| `PUBLIC_INPUT`, `PUBLIC_OUTPUT` | `2^12` | 3 bzw. 2 / 0 / 0 | 0 | 26 | 12.556 B, 12.524 B |
| `ADVICE_WINDOWS` | `2^22` | 3 / 0 / 0 | 0 | 46 | 36.316 B |
| `MOD_MUL` | `2^16` | 104 / 221 / 0 | 125 | 2.244 | 135.220 B |
| `SHA256_COMP` | `2^18` | 104 / 520 / 0 | 119 | 2.802 | 189.988 B |
| `EC_ADD` | `2^16` | 392 / 1.028 / 0 | 637 | 8.772 | 434.916 B |

Eine Höhe ändert nur die Zahl der halbierenden Listen und Sumcheck-Runden, nicht die Gates: Bei `2^20` hat `ADD_SUB_LUI_AUIPC` 298 innere Spalten und einen Beweis von 57.196 Byte, gegenüber 314 und 64.764 bei `2^22`.

## Speicher des Vorwärtsdurchlaufs

Der GKR-Prover hält jede innere Schicht als Körperelemente, 32 Byte pro Zelle. Repräsentativer Speicherbedarf:

| Shard | Vorwärtsdurchlauf |
| --- | --- |
| `SHIFT_BITWISE` bei `2^20` | 8,4 GiB |
| `MOD_MUL` bei `2^16` | 4,6 GB |
| `EC_ADD` bei `2^16` | 18,3 GB |
| `SHA256_COMP` bei `2^18` | 22,6 GB |
| `KECCAK_F` bei `2^18` | 42 GiB |

## Mercury

Auf einem Apple M5 Pro mit 18 Kernen:

| | |
| --- | --- |
| Commit, `n = 2^22` | 1,30 s |
| Öffnung, `n = 2^22` | 2,89 s |
| 16 Spalten der Größe `2^20` als ein Batch | geöffnet in 1,01 s, verifiziert in 4,8 ms |
| Dieselben 16 einzeln geöffnet | 9,79 s, verifiziert in 62 ms |

## Wie diese Zahlen zu lesen sind

Die Beweiserzeugung ist speichergebunden, und ihr Speicherbedarf folgt den gleichzeitig bearbeiteten Shards und deren Höhen, nie der Länge der Ausführung. Die Zeit folgt der Zyklenzahl, Familie für Familie. Die On-Chain-Kosten folgen der Zahl der Punkte, die die Wurzel dem finalen Pairing schuldet, mit etwa 9.000 gas pro Punkt. Zyklenzahlen selbst sind exakt und maschinenunabhängig; der Zyklus-Profiler ist also das richtige erste Werkzeug, um alles Übrige abzuschätzen.