Hoe we testen, volledig

De testopstelling

Dezelfde machine, dezelfde lijn, dezelfde inhoud

Elke client in een vergelijking draait op één machine, tegen dezelfde providers, op dezelfde inhoud, binnen dezelfde ronde. Er wordt niets meegenomen van een eerdere dag.

De machines. Een Apple M1 Ultra op een 10 GbE-lijn in Europa, en een M3 Ultra op een tragere lijn in de Verenigde Staten. Vergelijkingen mengen die twee nooit: een tabel is één machine.
De lijn telt zwaarder dan de processor. Op een 10 GbE-lijn kunnen de meeste clients de verbinding bij een makkelijke taak volledig benutten, en daarom zijn de interessante scenario's die waarin iets anders dan pure bandbreedte de uitkomst bepaalt.
Providers. Vijf commerciële providers, voor elke client dezelfde set, over TLS. We laten één provider buiten deze rondes omdat die beperkt hoeveel locaties tegelijk mogen verbinden, wat een gedeelde testmachine oneerlijk zou maken voor wie als tweede draait.
Verbindingen. Elke client krijgt in een ronde hetzelfde aantal per provider, en de ronde vermeldt welk. Meer is niet automatisch beter; we hebben onze eigen client gemeten die dezelfde eindtijd vasthield over een negenvoudige verandering van het aantal verbindingen.

De regel die alles bepaalt

Een client wordt beoordeeld op het bestand, niet op zijn eigen statusmelding

Dit is verreweg het belangrijkste op deze pagina. Elke run eindigt door het grootste bestand te zoeken dat de client heeft geproduceerd, waar dan ook in zijn uitvoer, en dat te hashen tegen een bekend goede kopie. Grootte en MD5, bij elke run, niet steekproefsgewijs.

We doen dit omdat het eigen succesbericht van een client geen betrouwbaar bewijs is. We hebben een client gemeten die done meldde bij een taak waarvan de uitvoermap leeg was. We hebben er nog een gemeten die Completed meldde na het afleveren van ruwe archiefvolumes die hij nooit had uitgepakt. Een veelgebruikt reparatiehulpmiddel eindigt met een foutcode na een geslaagde reparatie. Geen van die clients loog; statusteksten betekenen bij verschillende auteurs eenvoudigweg iets anders, en een benchmark die erop vertrouwt meet woordkeus in plaats van gedrag.

De eindstreep is dus voor iedereen dezelfde: de inhoud bestaat, met de juiste grootte en de juiste hash. Stopt een client daarvoor, dan krijgt hij geen tijd, en wordt de hele kolom gemarkeerd in plaats van stilletjes weggelaten. Een trage client die klaarkomt doet het beter dan een snelle die dat niet doet, en de tabel hoort dat te zeggen.

Het gevolg is dat niet-halen een resultaat is, geen fout van onze kant. Publiceren we er een, dan beschrijven we de eindtoestand in gewone woorden, inclusief alles wat erop wijst dat het specifiek voor die taak is en niet algemeen, en we zeggen wat de client in plaats van afmaken wél deed.

Volgorde en herhaling

Waarom runs elkaar afwisselen, en waarom losse runs niet worden gepubliceerd

De doorvoer van providers wisselt van minuut tot minuut, soms met een factor twee of drie. Twee metingen op verschillende momenten meten voor een deel het weer.

Clients draaien daarom direct achter elkaar en om en om, en de volgorde keert tussen herhalingen om, zodat geen client altijd degene is die als eerste een warme of koude lijn opgaat. Een resultaat is het patroon over de herhalingen heen, niet de beste run. Bij een grote spreiding publiceren we het bereik in plaats van een gemiddelde dat het zou verhullen, en als we niet weten waarom de cijfers van een client uiteenlopen, zeggen we dat in plaats van een oorzaak te verzinnen.

Vergelijkingen tussen verschillende rondes vermijden we waar mogelijk. Vraagt een bewering om twee cijfers, dan laten we ze liever allebei opnieuw draaien in één ronde dan dat we het cijfer van de ene dag van dat van de andere aftrekken, want de staat van de opstelling, de providercondities en de clientversies verschuiven allemaal. Vergelijken we twee van onze eigen builds, dan draaien beide in dezelfde ronde, om en om, op dezelfde inhoud.

De ongelijke controles

Wat er voor en tijdens elke run draait

De meeste bestaan omdat een stille storing ooit een gezond ogend, publiceerbaar en verkeerd getal opleverde. Elk ervan draait nu automatisch en zet de ronde stop in plaats van te waarschuwen.

Elke provider antwoordt voordat de run begint. Een run die draait terwijl twee providers plat liggen meet een storing, en dat ziet er precies uit als een trage client.
Het programmabestand wordt voor elke run op hash geïdentificeerd, niet op bestandsnaam of versietekst. Twee builds van ons meldden hetzelfde versienummer terwijl ze 88 commits uiteenliepen; alleen de hash houdt ze uit elkaar, en tabellen vermelden hem.
Elke client draait als machine-eigen code. Op Apple-machines kan een verkeerd gebouwd hulpprogramma stilletjes onder vertaling draaien, wat processortijd kost die aan onze verpakkingskeuze toebehoort en niet aan de code van de client. We controleren het draaiende proces, niet alleen het bestand.
De limieten voor open bestanden worden voor iedereen gelijk verhoogd. macOS start programma's met een limiet van 256 open bestanden, die een volledige set verbindingen kan overschrijden. Een client die eraan raakt verdwijnt meestal zonder crashrapport, wat precies leest als een gebrek in de software. Het schijnbare niet-halen van een concurrent bleek dit te zijn; met de limiet omhoog was dezelfde taak in 44 seconden klaar.
Schijfverkeer wordt per run vastgelegd, wat tegelijk controleert of niets anders de machine gebruikte. Die tellers beslaan de hele schijf in plaats van één programma, dus als er een tweede taak draaide zou het werk daarvan in onze metingen opduiken. Vlakke waarden over een hele ronde zijn hoe we weten dat een resultaat toebehoort aan de client die erbij staat.
Elke client schrijft naar zijn eigen uitvoerboom, en die boom wordt voor elke run gewist, zodat geen enkele run kan worden bevredigd door het bestand van een eerdere run.

Waar een client bepaalde instellingen nodig heeft om goed te presteren, krijgt hij die, en de ronde vermeldt welke. Voorbeelden: verzoeken bundelen aangezet waar een client het uit levert, dubbelcontrole uitgezet wanneer dezelfde taak herhaaldelijk wordt gedownload, en uitpakhulpjes uit het eigen pakket van de client in plaats van een systeemkopie. Het doel is dat elke client op zijn best wordt gemeten in plaats van op zijn standaardwaarden, want standaardwaarden zijn een discussie los van kunnen.

Wat we niet zullen doen

De grenzen van deze cijfers

We publiceren geen cijfer dat we niet hebben gemeten. Is een getal afgeleid in plaats van waargenomen, dan staat erbij dat het afgeleid is, en laten we liever een gat vallen dan het te vullen met rekenwerk dat als een meting leest.
We werken een verliezend resultaat niet stilletjes bij. Een run die we verliezen blijft gepubliceerd tot een herhaling hem vervangt, en wordt een verlies een winst, dan krijgt de verandering een toelichting naast de tabel in plaats van een stille bewerking.
De runs met providers zijn nog niet onafhankelijk reproduceerbaar, omdat de inhoud niet van ons is om te verspreiden. De componenttests, die gegenereerde inhoud gebruiken, zijn dat wel. We bereiden testbestanden voor die we kunnen publiceren, zodat ook de runs met providers controleerbaar worden.
Dit zijn onze benchmarks van andermans software. Elke versie wordt genoemd en gedateerd, en brengt een client een nieuwe uitgave uit, dan draaien we de runs die het raakt opnieuw in plaats van een verouderde vergelijking te laten staan. Vind je een resultaat onjuist, dan zijn de instellingen en versies gepubliceerd zodat er gericht over te twisten valt.