Graphics benchmark: scripted flights over four scenes at render distances 8/16/32, with CPU and GPU frame times

horizon-ctl gains 'fly' (a constant-speed camera path that replies with the
frame summary); frame summaries add CPU time per frame (waits for the GPU,
display and limiter excluded), per-phase averages and GPU time from timestamp
queries. --offscreen renders into a texture on the discrete GPU so the 4080
can be measured under the headless compositor. Baselines: lavapipe on vscreen
and the RTX 4080 offscreen, seed 1234.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-13 15:04:23 +02:00
parent 27a32cc30d
commit c982fadaf5
8 changed files with 1369 additions and 47 deletions
+392
View File
@@ -0,0 +1,392 @@
{
"label": "baseline-4080",
"date": "2026-10-13",
"commit": "27a32cc3",
"host": "ludodesktop",
"offscreen": true,
"seed": "1234",
"flight_seconds": 12.0,
"scenes": {
"village": {
"from": [
-960.0,
125.0,
80.0
],
"to": [
-960.0,
125.0,
272.0
],
"pitch": 35.0
},
"forest": {
"from": [
-1100.0,
120.0,
-560.0
],
"to": [
-1100.0,
120.0,
-368.0
],
"pitch": 25.0
},
"ocean": {
"from": [
-300.0,
85.0,
-420.0
],
"to": [
-300.0,
85.0,
-228.0
],
"pitch": 10.0
},
"mountain": {
"from": [
560.0,
260.0,
860.0
],
"to": [
752.0,
260.0,
860.0
],
"pitch": 30.0
}
},
"distances": {
"8": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 158,
"gpu": "NVIDIA GeForce RTX 4080",
"present_mode": "Immediate",
"size": [
1280,
720
],
"uploaded_bytes": 1137747200
},
"village": {
"avg_fps": 362.94072531330323,
"cpu": {
"avg_ms": 2.734311161203731,
"max_ms": 68.06377410888672,
"p50_ms": 1.4820960760116577,
"p95_ms": 7.922675609588623,
"p99_ms": 35.78989028930664
},
"frames": 4373,
"gpu": {
"avg_ms": 0.4188921034758625,
"max_ms": 2.5876479148864746,
"p50_ms": 0.4106239974498749,
"p95_ms": 0.5283839702606201,
"p99_ms": 0.5427200198173523
},
"low_1pct_fps": 21.64332698060583,
"max_ms": 68.08219146728516,
"p50_ms": 1.4894599914550781,
"p95_ms": 7.936410427093506,
"p99_ms": 36.54151153564453,
"seconds": 12.048799418210983
},
"forest": {
"avg_fps": 613.1553113846195,
"cpu": {
"avg_ms": 1.6186122214214547,
"max_ms": 216.98960876464844,
"p50_ms": 1.10076105594635,
"p95_ms": 3.0016868114471436,
"p99_ms": 10.144570350646973
},
"frames": 6746,
"gpu": {
"avg_ms": 0.395751640401594,
"max_ms": 1.99782395362854,
"p50_ms": 0.3983359932899475,
"p95_ms": 0.4833280146121979,
"p99_ms": 0.5375999808311462
},
"low_1pct_fps": 49.639170314777054,
"max_ms": 217.0211181640625,
"p50_ms": 1.109616994857788,
"p95_ms": 3.0161218643188477,
"p99_ms": 10.163111686706543,
"seconds": 11.002106439828873
},
"ocean": {
"avg_fps": 323.23791637473414,
"cpu": {
"avg_ms": 2.7230400277200597,
"max_ms": 4748.7744140625,
"p50_ms": 0.9233829975128174,
"p95_ms": 1.677724003791809,
"p99_ms": 7.7397589683532715
},
"frames": 3870,
"gpu": {
"avg_ms": 0.24116999250656182,
"max_ms": 0.954367995262146,
"p50_ms": 0.2754560112953186,
"p95_ms": 0.3389439880847931,
"p99_ms": 0.3532800078392029
},
"low_1pct_fps": 5.421154869716093,
"max_ms": 4748.80615234375,
"p50_ms": 0.9285120368003845,
"p95_ms": 1.7079449892044067,
"p99_ms": 33.33257293701172,
"seconds": 11.97260532861948
},
"mountain": {
"avg_fps": 28.19080143244723,
"cpu": {
"avg_ms": 12.358911560308298,
"max_ms": 187.3409881591797,
"p50_ms": 9.513923645019531,
"p95_ms": 25.783824920654297,
"p99_ms": 110.71585845947266
},
"frames": 338,
"gpu": {
"avg_ms": 0.46002139662497143,
"max_ms": 1.5626239776611328,
"p50_ms": 0.4546560049057007,
"p95_ms": 0.5140479803085327,
"p99_ms": 0.5959680080413818
},
"low_1pct_fps": 7.428141780247131,
"max_ms": 187.36033630371094,
"p50_ms": 33.334835052490234,
"p95_ms": 35.65903854370117,
"p99_ms": 110.73509216308594,
"seconds": 11.98972653579712
}
},
"16": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 1,
"gpu": "NVIDIA GeForce RTX 4080",
"present_mode": "Immediate",
"size": [
1280,
720
],
"uploaded_bytes": 54284928
},
"village": {
"avg_fps": 7.569165639843409,
"cpu": {
"avg_ms": 138.25648041658624,
"max_ms": 877.6473999023438,
"p50_ms": 103.97663879394531,
"p95_ms": 318.5262145996094,
"p99_ms": 877.6473999023438
},
"frames": 86,
"gpu": {
"avg_ms": 3.585262137790059,
"max_ms": 8.415231704711914,
"p50_ms": 3.299328088760376,
"p95_ms": 7.171072006225586,
"p99_ms": 8.415231704711914
},
"low_1pct_fps": 2.44461512120682,
"max_ms": 409.0623474121094,
"p50_ms": 104.01687622070312,
"p95_ms": 318.5569763183594,
"p99_ms": 409.0623474121094,
"seconds": 11.361886381149292
},
"forest": {
"avg_fps": 27.65529078792617,
"cpu": {
"avg_ms": 37.926895780927815,
"max_ms": 3484.08349609375,
"p50_ms": 3.398620128631592,
"p95_ms": 44.56385040283203,
"p99_ms": 684.4393920898438
},
"frames": 314,
"gpu": {
"avg_ms": 2.683724634467986,
"max_ms": 9.881600379943848,
"p50_ms": 1.8923519849777222,
"p95_ms": 7.221248149871826,
"p99_ms": 9.04089641571045
},
"low_1pct_fps": 0.4753349245465373,
"max_ms": 3484.115234375,
"p50_ms": 3.5420219898223877,
"p95_ms": 44.591251373291016,
"p99_ms": 159.3817901611328,
"seconds": 11.354066113710404
},
"ocean": {
"avg_fps": 59.16125632179682,
"cpu": {
"avg_ms": 16.807428855239674,
"max_ms": 106.0348129272461,
"p50_ms": 9.335607528686523,
"p95_ms": 44.57380294799805,
"p99_ms": 84.97154998779297
},
"frames": 712,
"gpu": {
"avg_ms": 1.958949391112736,
"max_ms": 8.635392189025879,
"p50_ms": 1.1182080507278442,
"p95_ms": 5.493760108947754,
"p99_ms": 7.108607769012451
},
"low_1pct_fps": 10.542641239411056,
"max_ms": 106.06544494628906,
"p50_ms": 9.364562034606934,
"p95_ms": 45.14366912841797,
"p99_ms": 84.9927749633789,
"seconds": 12.034903317928315
},
"mountain": {
"avg_fps": 26.78175419456072,
"cpu": {
"avg_ms": 20.230309660251326,
"max_ms": 128.05508422851562,
"p50_ms": 15.369550704956055,
"p95_ms": 67.15973663330078,
"p99_ms": 104.6961898803711
},
"frames": 325,
"gpu": {
"avg_ms": 7.143625645270714,
"max_ms": 21.25823974609375,
"p50_ms": 7.187456130981445,
"p95_ms": 12.228608131408691,
"p99_ms": 19.310592651367188
},
"low_1pct_fps": 7.777799947825389,
"max_ms": 155.30685424804688,
"p50_ms": 33.335182189941406,
"p95_ms": 68.94293975830078,
"p99_ms": 109.09304809570312,
"seconds": 12.135127431869506
}
},
"32": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 0,
"gpu": "NVIDIA GeForce RTX 4080",
"present_mode": "Immediate",
"size": [
1280,
720
],
"uploaded_bytes": 4829184
},
"village": {
"avg_fps": 4.1477100728464,
"cpu": {
"avg_ms": 244.17284844846142,
"max_ms": 386.7664489746094,
"p50_ms": 244.8783416748047,
"p95_ms": 363.0765380859375,
"p99_ms": 386.7664489746094
},
"frames": 49,
"gpu": {
"avg_ms": 10.357822744213806,
"max_ms": 23.010303497314453,
"p50_ms": 9.227264404296875,
"p95_ms": 19.309568405151367,
"p99_ms": 23.010303497314453
},
"low_1pct_fps": 2.5853636290905797,
"max_ms": 386.79278564453125,
"p50_ms": 230.8652801513672,
"p95_ms": 363.0941162109375,
"p99_ms": 386.79278564453125,
"seconds": 11.813747619628906
},
"forest": {
"avg_fps": 8.3624969613463,
"cpu": {
"avg_ms": 118.74922356747165,
"max_ms": 278.8187255859375,
"p50_ms": 123.03407287597656,
"p95_ms": 231.6608123779297,
"p99_ms": 260.8450622558594
},
"frames": 101,
"gpu": {
"avg_ms": 15.898816661669477,
"max_ms": 72.880126953125,
"p50_ms": 20.789247512817383,
"p95_ms": 28.441600799560547,
"p99_ms": 60.816383361816406
},
"low_1pct_fps": 3.7057290596141406,
"max_ms": 278.83917236328125,
"p50_ms": 123.19290161132812,
"p95_ms": 231.68026733398438,
"p99_ms": 260.8656921386719,
"seconds": 12.077732340812684
},
"ocean": {
"avg_fps": 2.3954947141714045,
"cpu": {
"avg_ms": 424.7621285574777,
"max_ms": 625.8532104492188,
"p50_ms": 435.64044189453125,
"p95_ms": 577.7593994140625,
"p99_ms": 625.8532104492188
},
"frames": 28,
"gpu": {
"avg_ms": 9.483117733682905,
"max_ms": 12.973055839538574,
"p50_ms": 9.90719985961914,
"p95_ms": 12.610560417175293,
"p99_ms": 12.973055839538574
},
"low_1pct_fps": 1.5977632874291703,
"max_ms": 625.8749389648438,
"p50_ms": 433.9859619140625,
"p95_ms": 577.7803955078125,
"p99_ms": 625.8749389648438,
"seconds": 11.688608551025391
},
"mountain": {
"avg_fps": 3.3756775332390268,
"cpu": {
"avg_ms": 300.512197249975,
"max_ms": 407.4363708496094,
"p50_ms": 292.483642578125,
"p95_ms": 394.8424377441406,
"p99_ms": 407.4363708496094
},
"frames": 39,
"gpu": {
"avg_ms": 9.728866460995796,
"max_ms": 18.930688858032227,
"p50_ms": 8.820735931396484,
"p95_ms": 17.399808883666992,
"p99_ms": 18.930688858032227
},
"low_1pct_fps": 2.4541792422631716,
"max_ms": 407.46820068359375,
"p50_ms": 292.4177551269531,
"p95_ms": 394.8649597167969,
"p99_ms": 407.46820068359375,
"seconds": 11.553236236572266
}
}
}
}
+392
View File
@@ -0,0 +1,392 @@
{
"label": "baseline-lavapipe",
"date": "2026-10-13",
"commit": "27a32cc3",
"host": "ludodesktop",
"offscreen": false,
"seed": "1234",
"flight_seconds": 12.0,
"scenes": {
"village": {
"from": [
-960.0,
125.0,
80.0
],
"to": [
-960.0,
125.0,
272.0
],
"pitch": 35.0
},
"forest": {
"from": [
-1100.0,
120.0,
-560.0
],
"to": [
-1100.0,
120.0,
-368.0
],
"pitch": 25.0
},
"ocean": {
"from": [
-300.0,
85.0,
-420.0
],
"to": [
-300.0,
85.0,
-228.0
],
"pitch": 10.0
},
"mountain": {
"from": [
560.0,
260.0,
860.0
],
"to": [
752.0,
260.0,
860.0
],
"pitch": 30.0
}
},
"distances": {
"8": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 146,
"gpu": "llvmpipe (LLVM 21.1.8, 256 bits)",
"present_mode": "Mailbox",
"size": [
1600,
1000
],
"uploaded_bytes": 1288851072
},
"village": {
"avg_fps": 16.38225374384963,
"cpu": {
"avg_ms": 48.17248754105975,
"max_ms": 134.31028747558594,
"p50_ms": 44.57072067260742,
"p95_ms": 97.15985870361328,
"p99_ms": 127.31073760986328
},
"frames": 199,
"gpu": {
"avg_ms": 26.732369270324707,
"max_ms": 47.3107795715332,
"p50_ms": 26.284116744995117,
"p95_ms": 35.006874084472656,
"p99_ms": 39.38005828857422
},
"low_1pct_fps": 6.569673692138871,
"max_ms": 169.97352600097656,
"p50_ms": 56.791988372802734,
"p95_ms": 109.15220642089844,
"p99_ms": 134.45559692382812,
"seconds": 12.147290788650512
},
"forest": {
"avg_fps": 19.917172468484612,
"cpu": {
"avg_ms": 31.039839970568817,
"max_ms": 106.39506530761719,
"p50_ms": 33.26064682006836,
"p95_ms": 70.09876251220703,
"p99_ms": 86.21255493164062
},
"frames": 240,
"gpu": {
"avg_ms": 37.272586759195285,
"max_ms": 77.586669921875,
"p50_ms": 34.38500213623047,
"p95_ms": 59.649635314941406,
"p99_ms": 66.52396392822266
},
"low_1pct_fps": 9.909291086862112,
"max_ms": 106.57542419433594,
"p50_ms": 46.05862808227539,
"p95_ms": 80.38935852050781,
"p99_ms": 94.94140625,
"seconds": 12.049903186798096
},
"ocean": {
"avg_fps": 27.969763129786234,
"cpu": {
"avg_ms": 25.69895526429727,
"max_ms": 930.7354125976562,
"p50_ms": 18.981081008911133,
"p95_ms": 39.42117691040039,
"p99_ms": 168.07225036621094
},
"frames": 336,
"gpu": {
"avg_ms": 18.856842384451912,
"max_ms": 57.835872650146484,
"p50_ms": 18.172868728637695,
"p95_ms": 28.62451171875,
"p99_ms": 44.414398193359375
},
"low_1pct_fps": 1.527565223414601,
"max_ms": 930.8734741210938,
"p50_ms": 26.45800018310547,
"p95_ms": 50.053672790527344,
"p99_ms": 180.92478942871094,
"seconds": 12.012972667694092
},
"mountain": {
"avg_fps": 26.5942562164059,
"cpu": {
"avg_ms": 22.482411369495093,
"max_ms": 104.89199829101562,
"p50_ms": 22.033512115478516,
"p95_ms": 46.385555267333984,
"p99_ms": 61.15697479248047
},
"frames": 320,
"gpu": {
"avg_ms": 23.762589550018312,
"max_ms": 48.10239028930664,
"p50_ms": 22.580347061157227,
"p95_ms": 35.14606475830078,
"p99_ms": 42.47938919067383
},
"low_1pct_fps": 11.197907022053611,
"max_ms": 105.07585906982422,
"p50_ms": 33.362815856933594,
"p95_ms": 53.36695098876953,
"p99_ms": 74.80219268798828,
"seconds": 12.03267342376709
}
},
"16": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 1,
"gpu": "llvmpipe (LLVM 21.1.8, 256 bits)",
"present_mode": "Mailbox",
"size": [
1600,
1000
],
"uploaded_bytes": 16106880
},
"village": {
"avg_fps": 10.754658718707336,
"cpu": {
"avg_ms": 69.22208800682655,
"max_ms": 193.21267700195312,
"p50_ms": 66.95130157470703,
"p95_ms": 154.44834899902344,
"p99_ms": 191.29208374023438
},
"frames": 130,
"gpu": {
"avg_ms": 49.041961078495945,
"max_ms": 73.83775329589844,
"p50_ms": 48.90928268432617,
"p95_ms": 60.60416793823242,
"p99_ms": 66.1044921875
},
"low_1pct_fps": 4.171866301284614,
"max_ms": 252.21458435058594,
"p50_ms": 79.8940200805664,
"p95_ms": 173.05947875976562,
"p99_ms": 227.18716430664062,
"seconds": 12.087784782409669
},
"forest": {
"avg_fps": 12.167278778001634,
"cpu": {
"avg_ms": 58.366991678873696,
"max_ms": 156.683349609375,
"p50_ms": 69.24014282226562,
"p95_ms": 110.83757019042969,
"p99_ms": 134.16554260253906
},
"frames": 147,
"gpu": {
"avg_ms": 56.45229888606716,
"max_ms": 78.26596069335938,
"p50_ms": 55.92947006225586,
"p95_ms": 63.54412841796875,
"p99_ms": 66.5202407836914
},
"low_1pct_fps": 5.722095670390665,
"max_ms": 212.99729919433594,
"p50_ms": 77.36986541748047,
"p95_ms": 122.84784698486328,
"p99_ms": 136.52499389648438,
"seconds": 12.081583950042724
},
"ocean": {
"avg_fps": 7.681804845753147,
"cpu": {
"avg_ms": 98.35419226740743,
"max_ms": 385.2493591308594,
"p50_ms": 78.85044860839844,
"p95_ms": 225.36231994628906,
"p99_ms": 385.2493591308594
},
"frames": 91,
"gpu": {
"avg_ms": 71.51263585297957,
"max_ms": 128.29212951660156,
"p50_ms": 67.92412567138672,
"p95_ms": 101.93219757080078,
"p99_ms": 128.29212951660156
},
"low_1pct_fps": 2.5948566279945817,
"max_ms": 385.37774658203125,
"p50_ms": 123.91693878173828,
"p95_ms": 225.49420166015625,
"p99_ms": 385.37774658203125,
"seconds": 11.846174411773681
},
"mountain": {
"avg_fps": 5.886844433101332,
"cpu": {
"avg_ms": 124.87309415575484,
"max_ms": 321.2157897949219,
"p50_ms": 117.2811050415039,
"p95_ms": 237.34304809570312,
"p99_ms": 321.2157897949219
},
"frames": 71,
"gpu": {
"avg_ms": 95.46965434816148,
"max_ms": 166.9488067626953,
"p50_ms": 83.54202270507812,
"p95_ms": 160.2403564453125,
"p99_ms": 166.9488067626953
},
"low_1pct_fps": 3.111272818975726,
"max_ms": 321.411865234375,
"p50_ms": 153.0963134765625,
"p95_ms": 275.37579345703125,
"p99_ms": 321.411865234375,
"seconds": 12.060790939331055
}
},
"32": {
"renderer": {
"backend": "Vulkan",
"drawn_sections": 1,
"gpu": "llvmpipe (LLVM 21.1.8, 256 bits)",
"present_mode": "Mailbox",
"size": [
1600,
1000
],
"uploaded_bytes": 19154560
},
"village": {
"avg_fps": 2.5956714101148957,
"cpu": {
"avg_ms": 345.63314671670236,
"max_ms": 474.2013854980469,
"p50_ms": 347.07415771484375,
"p95_ms": 468.0090026855469,
"p99_ms": 474.2013854980469
},
"frames": 31,
"gpu": {
"avg_ms": 85.50063645839691,
"max_ms": 134.11460876464844,
"p50_ms": 82.40946960449219,
"p95_ms": 133.71929931640625,
"p99_ms": 134.11460876464844
},
"low_1pct_fps": 2.01406006678458,
"max_ms": 496.509521484375,
"p50_ms": 390.230224609375,
"p95_ms": 493.8070373535156,
"p99_ms": 496.509521484375,
"seconds": 11.942960067749024
},
"forest": {
"avg_fps": 2.2283930626963917,
"cpu": {
"avg_ms": 354.7813931978666,
"max_ms": 611.8099975585938,
"p50_ms": 293.61376953125,
"p95_ms": 601.3502197265625,
"p99_ms": 611.8099975585938
},
"frames": 26,
"gpu": {
"avg_ms": 201.54420654296874,
"max_ms": 357.0310363769531,
"p50_ms": 172.65980529785156,
"p95_ms": 341.8655700683594,
"p99_ms": 357.0310363769531
},
"low_1pct_fps": 1.52339962842959,
"max_ms": 656.4265747070312,
"p50_ms": 407.1051330566406,
"p95_ms": 611.97119140625,
"p99_ms": 656.4265747070312,
"seconds": 11.667600494384766
},
"ocean": {
"avg_fps": 2.6137193379326398,
"cpu": {
"avg_ms": 330.783615620931,
"max_ms": 730.7304077148438,
"p50_ms": 296.65692138671875,
"p95_ms": 680.8717041015625,
"p99_ms": 730.7304077148438
},
"frames": 30,
"gpu": {
"avg_ms": 113.80178985595703,
"max_ms": 216.57342529296875,
"p50_ms": 104.23703002929688,
"p95_ms": 193.67672729492188,
"p99_ms": 216.57342529296875
},
"low_1pct_fps": 1.1784160273210693,
"max_ms": 848.5967407226562,
"p50_ms": 346.120849609375,
"p95_ms": 681.0716552734375,
"p99_ms": 848.5967407226562,
"seconds": 11.477896484375
},
"mountain": {
"avg_fps": 2.72441042065798,
"cpu": {
"avg_ms": 325.24547207740045,
"max_ms": 578.7177124023438,
"p50_ms": 295.25457763671875,
"p95_ms": 569.8099975585938,
"p99_ms": 578.7177124023438
},
"frames": 31,
"gpu": {
"avg_ms": 104.99177145957947,
"max_ms": 163.95635986328125,
"p50_ms": 99.96784210205078,
"p95_ms": 160.04824829101562,
"p99_ms": 163.95635986328125
},
"low_1pct_fps": 1.7544071931551564,
"max_ms": 569.9931030273438,
"p50_ms": 378.246337890625,
"p95_ms": 555.5369873046875,
"p99_ms": 569.9931030273438,
"seconds": 11.378608657836914
}
}
}
}
+58 -1
View File
@@ -140,10 +140,38 @@ fn serve(stream: UnixStream, sender: &mpsc::Sender<Request>) {
}
}
/// Frame durations since the last reset, summarized like the Java recorder.
/// Frame durations since the last reset, summarized like the Java recorder,
/// with the CPU part of each frame and GPU times from timestamp queries.
#[derive(Default)]
pub struct FrameStats {
millis: Vec<f32>,
cpu: Vec<f32>,
gpu: Vec<f32>,
/// Summed milliseconds per frame phase (`PHASES`) and the frames counted.
phases: [f64; PHASES.len()],
phase_frames: u64,
}
/// The parts of a frame's CPU time: world streaming and uploads, game ticks,
/// building the frame's geometry and HUD, and the renderer's own work.
pub const PHASES: [&str; 4] = ["update", "tick", "prepare", "render"];
fn percentiles(values: &[f32]) -> serde_json::Value {
let mut sorted = values.to_vec();
sorted.sort_by(f32::total_cmp);
let n = sorted.len();
if n == 0 {
return serde_json::Value::Null;
}
let total: f64 = sorted.iter().map(|&m| f64::from(m)).sum();
let percentile = |p: f64| sorted[((n as f64 * p).ceil() as usize).clamp(1, n) - 1];
serde_json::json!({
"avg_ms": total / n as f64,
"p50_ms": percentile(0.5),
"p95_ms": percentile(0.95),
"p99_ms": percentile(0.99),
"max_ms": sorted[n - 1],
})
}
impl FrameStats {
@@ -153,8 +181,30 @@ impl FrameStats {
self.millis.push(millis);
}
}
/// The frame's own work: its duration minus waits for the GPU, the
/// display and the frame limiter.
pub fn record_cpu(&mut self, millis: f32) {
if self.cpu.len() < Self::LIMIT {
self.cpu.push(millis);
}
}
pub fn record_phases(&mut self, millis: [f32; PHASES.len()]) {
for (sum, m) in self.phases.iter_mut().zip(millis) {
*sum += f64::from(m);
}
self.phase_frames += 1;
}
pub fn record_gpu(&mut self, millis: &[f32]) {
if self.gpu.len() < Self::LIMIT {
self.gpu.extend_from_slice(millis);
}
}
pub fn reset(&mut self) {
self.millis.clear();
self.cpu.clear();
self.gpu.clear();
self.phases = [0.0; PHASES.len()];
self.phase_frames = 0;
}
pub fn summary(&self) -> serde_json::Value {
let mut sorted = self.millis.clone();
@@ -181,6 +231,13 @@ impl FrameStats {
"p95_ms": percentile(0.95),
"p99_ms": percentile(0.99),
"max_ms": sorted[n - 1],
"cpu": percentiles(&self.cpu),
"gpu": percentiles(&self.gpu),
"phases_avg_ms": PHASES
.iter()
.zip(self.phases)
.map(|(name, sum)| (name.to_string(), (sum / self.phase_frames.max(1) as f64).into()))
.collect::<serde_json::Map<_, _>>(),
})
}
}
+28
View File
@@ -183,6 +183,9 @@ struct Options {
no_pause: bool,
/// Control socket path (`--control`), for `horizon-ctl`.
control: Option<PathBuf>,
/// Render into a texture instead of the window (`--offscreen`), so a
/// GPU the display cannot present from can still be benchmarked.
offscreen: bool,
/// Multiplayer: `--server HOST[:PORT]` joins at start; `--name` is the offline player name.
server: Option<String>,
player_name: String,
@@ -218,6 +221,7 @@ impl Options {
dimension: None,
no_pause: false,
control: None,
offscreen: false,
server: None,
player_name: std::env::var("HORIZON_PLAYER_NAME").unwrap_or_else(|_| "Player".into()),
dedicated: None,
@@ -238,6 +242,7 @@ impl Options {
"--creative" => o.creative = true,
"--test-terrain" => o.test_terrain = true,
"--no-pause" => o.no_pause = true,
"--offscreen" => o.offscreen = true,
"--control" => o.control = Some(horizon_client::control::default_path()),
_ => {
let value = args
@@ -776,6 +781,8 @@ struct Game<'a> {
/// Control replies waiting for a rendered frame or a benchmark deadline.
pending_screenshot: Option<std::sync::mpsc::Sender<String>>,
pending_bench: Option<(Instant, std::sync::mpsc::Sender<String>)>,
/// A scripted flight from the control socket (`fly`).
flight: Option<control::Flight>,
persist: persist::EntityMemory,
/// Connected to a server: the world comes from the network (game/remote.rs).
remote: Option<remote::Remote>,
@@ -7593,6 +7600,7 @@ impl ApplicationHandler for Game<'_> {
let assets = &self.res.assets;
match pollster::block_on(Renderer::new(
window.clone(),
self.options.offscreen,
&assets.pixels,
assets.sprite_size,
assets.texture_layers,
@@ -8005,6 +8013,7 @@ impl ApplicationHandler for Game<'_> {
self.update_world();
self.spawn_player()?;
}
let updated = Instant::now();
self.track_toggle_screens();
let steps = self.clock.advance(elapsed);
for _ in 0..steps {
@@ -8022,7 +8031,25 @@ impl ApplicationHandler for Game<'_> {
}
}
self.apply_mouse_look();
self.advance_flight();
let ticked = Instant::now();
let rendered = self.render()?;
if let Some(r) = self.renderer.as_mut() {
let cpu = now.elapsed().saturating_sub(r.last_wait);
if rendered {
let ms = |d: Duration| d.as_secs_f32() * 1000.0;
self.frame_stats.record_cpu(ms(cpu));
let render = r.last_encode;
self.frame_stats.record_phases([
ms(updated - now),
ms(ticked - updated),
ms(ticked.elapsed().saturating_sub(r.last_wait + render)),
ms(render),
]);
}
self.frame_stats.record_gpu(&r.gpu_times);
r.gpu_times.clear();
}
self.limit_frame();
self.pause = self.pauses_game();
self.clock.end_frame(self.pause);
@@ -8428,6 +8455,7 @@ pub fn run() -> Result<()> {
frame_stats: Default::default(),
pending_screenshot: None,
pending_bench: None,
flight: None,
persist: Default::default(),
remote: None,
lan: None,
+54
View File
@@ -32,6 +32,7 @@ const HELP: &[&str] = &[
"options [PAGE] open the options (video sound controls keybinds mouse chat accessibility language font packs)",
"stats [reset] frame-time summary since the last reset",
"bench SECONDS reset stats, wait, then reply with the summary",
"fly X1 Y1 Z1 X2 Y2 Z2 SECONDS [PITCH] fly the camera along a line at constant speed, then reply with the frame summary",
"open WORLD [SEED] [creative] open or create a world from the title screen",
"save save the world",
"save-all save the world, rewriting every resident chunk",
@@ -42,7 +43,42 @@ const HELP: &[&str] = &[
"quit save and exit",
];
/// A straight camera path at constant speed, for repeatable benchmarks: the
/// player is placed on it every frame, facing along it.
pub struct Flight {
from: Vec3,
to: Vec3,
pitch: f32,
started: Instant,
seconds: f64,
reply: Sender<String>,
}
impl Game<'_> {
/// Move the camera along the running flight; reply when it ends.
pub(super) fn advance_flight(&mut self) {
let Some(flight) = &self.flight else { return };
let t = (flight.started.elapsed().as_secs_f64() / flight.seconds).min(1.0);
let (a, b) = (flight.from, flight.to);
let d = [b.x - a.x, b.y - a.y, b.z - a.z];
let at = Vec3::new(a.x + d[0] * t, a.y + d[1] * t, a.z + d[2] * t);
// Minecraft yaw: 0 faces +Z, 90 faces -X.
self.yaw = (-d[0]).atan2(d[2]).to_degrees() as f32;
self.pitch = flight.pitch;
if let Some(player) = self.player.as_mut() {
player.position = at;
player.velocity = Vec3::new(0.0, 0.0, 0.0);
player.fall_distance = 0.0;
// Stay where the flight ends (creative flight).
player.flying = true;
self.previous_position = at;
}
if t >= 1.0
&& let Some(flight) = self.flight.take()
{
let _ = flight.reply.send(self.frame_stats.summary().to_string());
}
}
pub(super) fn poll_control(&mut self, event_loop: &ActiveEventLoop) {
if let Some((deadline, reply)) = self.pending_bench.take() {
if Instant::now() >= deadline {
@@ -357,6 +393,24 @@ impl Game<'_> {
));
Ok(None)
}
"fly" => {
self.require_world()?;
if self.flight.is_some() || self.pending_bench.is_some() {
return Err("a benchmark is already running".into());
}
let n = |i: usize| -> Result<f64> { Ok(arg(i)?.parse()?) };
let pitch = words.get(8).map_or(Ok(10.0), |p| p.parse::<f32>())?;
self.frame_stats.reset();
self.flight = Some(Flight {
from: Vec3::new(n(1)?, n(2)?, n(3)?),
to: Vec3::new(n(4)?, n(5)?, n(6)?),
pitch,
started: Instant::now(),
seconds: n(7)?.max(0.1),
reply: reply.clone(),
});
Ok(None)
}
"open" => {
if self.title.is_none() {
return Err("a world is already open".into());
+160 -46
View File
@@ -13,6 +13,8 @@ use std::{collections::HashMap, path::PathBuf, sync::Arc, time::Instant};
use wgpu::util::DeviceExt;
use winit::window::Window;
mod timing;
#[repr(C)]
#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
struct Globals {
@@ -115,7 +117,20 @@ struct BorderUniform {
}
pub struct Renderer {
instance: wgpu::Instance,
surface: wgpu::Surface<'static>,
/// The window's swapchain; `None` when rendering offscreen (`--offscreen`).
surface: Option<wgpu::Surface<'static>>,
/// The offscreen colour target, sized like `config`.
offscreen: Option<wgpu::Texture>,
/// Offscreen submissions still on the GPU: at most two frames run ahead.
in_flight: std::collections::VecDeque<wgpu::SubmissionIndex>,
gpu_timer: Option<timing::GpuTimer>,
/// GPU frame times (ms) read back since the caller last drained them.
pub gpu_times: Vec<f32>,
/// Time the last `render` spent blocked on the GPU or the display
/// (acquiring, presenting, offscreen pacing), excluded from CPU time.
pub last_wait: std::time::Duration,
/// CPU time of the last `render`, waits excluded.
pub last_encode: std::time::Duration,
window: Arc<Window>,
pub device: wgpu::Device,
pub queue: wgpu::Queue,
@@ -217,6 +232,7 @@ fn mip_chain(pixels: &[u8], size: u32, layers: u32) -> (Vec<u8>, u32) {
impl Renderer {
pub async fn new(
window: Arc<Window>,
offscreen: bool,
sprite_pixels: &[u8],
sprite_size: u32,
layers: u32,
@@ -226,11 +242,17 @@ impl Renderer {
) -> Result<Self> {
let instance =
wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle_from_env());
let surface = instance.create_surface(window.clone())?;
// Offscreen rendering needs no surface, so it can use a GPU the
// window's display cannot present from (a headless compositor).
let surface = if offscreen {
None
} else {
Some(instance.create_surface(window.clone())?)
};
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::HighPerformance,
compatible_surface: Some(&surface),
compatible_surface: surface.as_ref(),
force_fallback_adapter: false,
..Default::default()
})
@@ -251,34 +273,56 @@ impl Renderer {
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor {
label: Some("Horizon device"),
required_features: timing::GpuTimer::features(&adapter)
| (adapter.features() & wgpu::Features::INDIRECT_FIRST_INSTANCE),
required_limits: limits.clone(),
..Default::default()
})
.await?;
let size = window.inner_size();
let mut config = surface
.get_default_config(&adapter, size.width.max(1), size.height.max(1))
.ok_or("surface has no supported configuration")?;
let caps = surface.get_capabilities(&adapter);
// Vanilla blends and tints in gamma space: use a non-sRGB target.
config.format = caps
.formats
.iter()
.copied()
.find(|f| !f.is_srgb())
.unwrap_or(config.format);
config.view_formats = vec![config.format.remove_srgb_suffix()];
// Screenshots copy the presented frame back from the swapchain.
if caps.usages.contains(wgpu::TextureUsages::COPY_SRC) {
config.usage |= wgpu::TextureUsages::COPY_SRC;
}
let present_modes = caps.present_modes.clone();
config.present_mode = if caps.present_modes.contains(&wgpu::PresentMode::Mailbox) {
wgpu::PresentMode::Mailbox
let (config, present_modes) = if let Some(surface) = &surface {
let mut config = surface
.get_default_config(&adapter, size.width.max(1), size.height.max(1))
.ok_or("surface has no supported configuration")?;
let caps = surface.get_capabilities(&adapter);
// Vanilla blends and tints in gamma space: use a non-sRGB target.
config.format = caps
.formats
.iter()
.copied()
.find(|f| !f.is_srgb())
.unwrap_or(config.format);
config.view_formats = vec![config.format.remove_srgb_suffix()];
// Screenshots copy the presented frame back from the swapchain.
if caps.usages.contains(wgpu::TextureUsages::COPY_SRC) {
config.usage |= wgpu::TextureUsages::COPY_SRC;
}
config.present_mode = if caps.present_modes.contains(&wgpu::PresentMode::Mailbox) {
wgpu::PresentMode::Mailbox
} else {
wgpu::PresentMode::Fifo
};
surface.configure(&device, &config);
(config, caps.present_modes.clone())
} else {
wgpu::PresentMode::Fifo
let format = wgpu::TextureFormat::Bgra8Unorm;
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
format,
width: size.width.max(1),
height: size.height.max(1),
present_mode: wgpu::PresentMode::Immediate,
desired_maximum_frame_latency: 2,
alpha_mode: wgpu::CompositeAlphaMode::Opaque,
view_formats: vec![format],
color_space: wgpu::SurfaceColorSpace::default(),
};
(config, Vec::new())
};
surface.configure(&device, &config);
let offscreen = surface
.is_none()
.then(|| Self::offscreen_target(&device, &config));
let gpu_timer = timing::GpuTimer::new(&device, &queue);
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Horizon terrain"),
source: wgpu::ShaderSource::Wgsl(include_str!("terrain.wgsl").into()),
@@ -1044,6 +1088,12 @@ impl Renderer {
Ok(Self {
instance,
surface,
offscreen,
in_flight: std::collections::VecDeque::new(),
gpu_timer,
gpu_times: Vec::new(),
last_wait: std::time::Duration::ZERO,
last_encode: std::time::Duration::ZERO,
window,
device,
queue,
@@ -1110,6 +1160,29 @@ impl Renderer {
usage: wgpu::BufferUsages::INDEX,
})
}
fn offscreen_target(
device: &wgpu::Device,
config: &wgpu::SurfaceConfiguration,
) -> wgpu::Texture {
device.create_texture(&wgpu::TextureDescriptor {
label: Some("Offscreen frame"),
size: wgpu::Extent3d {
width: config.width,
height: config.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: config.format,
usage: config.usage,
view_formats: &config.view_formats,
})
}
/// Rendering to a texture instead of the window (`--offscreen`).
pub fn is_offscreen(&self) -> bool {
self.surface.is_none()
}
fn depth(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> wgpu::TextureView {
device
.create_texture(&wgpu::TextureDescriptor {
@@ -1147,9 +1220,11 @@ impl Renderer {
Some(PresentMode::Immediate) => wgpu::PresentMode::Immediate,
_ => wgpu::PresentMode::Fifo,
};
if self.config.present_mode != mode {
if self.config.present_mode != mode
&& let Some(surface) = &self.surface
{
self.config.present_mode = mode;
self.surface.configure(&self.device, &self.config);
surface.configure(&self.device, &self.config);
}
}
pub fn resize(&mut self, width: u32, height: u32) {
@@ -1159,7 +1234,11 @@ impl Renderer {
}
self.config.width = width;
self.config.height = height;
self.surface.configure(&self.device, &self.config);
if let Some(surface) = &self.surface {
surface.configure(&self.device, &self.config);
} else {
self.offscreen = Some(Self::offscreen_target(&self.device, &self.config));
}
self.depth = Self::depth(&self.device, &self.config);
}
pub fn section_count(&self) -> usize {
@@ -1387,25 +1466,37 @@ impl Renderer {
if self.suspended {
return Ok(false);
}
let (surface_frame, reconfigure) = match self.surface.get_current_texture() {
wgpu::CurrentSurfaceTexture::Success(f) => (f, false),
wgpu::CurrentSurfaceTexture::Suboptimal(f) => (f, true),
wgpu::CurrentSurfaceTexture::Timeout | wgpu::CurrentSurfaceTexture::Occluded => {
let started = Instant::now();
let acquire = Instant::now();
let acquired = self.surface.as_ref().map(|s| s.get_current_texture());
self.last_wait = acquire.elapsed();
let (surface_frame, reconfigure) = match acquired {
None => (None, false),
Some(wgpu::CurrentSurfaceTexture::Success(f)) => (Some(f), false),
Some(wgpu::CurrentSurfaceTexture::Suboptimal(f)) => (Some(f), true),
Some(wgpu::CurrentSurfaceTexture::Timeout | wgpu::CurrentSurfaceTexture::Occluded) => {
return Ok(false);
}
wgpu::CurrentSurfaceTexture::Outdated => {
self.surface.configure(&self.device, &self.config);
Some(wgpu::CurrentSurfaceTexture::Outdated) => {
if let Some(surface) = &self.surface {
surface.configure(&self.device, &self.config);
}
return Ok(false);
}
wgpu::CurrentSurfaceTexture::Lost => {
self.surface = self.instance.create_surface(self.window.clone())?;
self.surface.configure(&self.device, &self.config);
Some(wgpu::CurrentSurfaceTexture::Lost) => {
let surface = self.instance.create_surface(self.window.clone())?;
surface.configure(&self.device, &self.config);
self.surface = Some(surface);
return Ok(false);
}
wgpu::CurrentSurfaceTexture::Validation => {
Some(wgpu::CurrentSurfaceTexture::Validation) => {
return Err("surface acquisition failed validation".into());
}
};
let target_texture = match &surface_frame {
Some(f) => f.texture.clone(),
None => self.offscreen.clone().ok_or("no offscreen target")?,
};
self.animate(frame.ticks);
self.update_lightmap(
&frame.sky,
@@ -1650,9 +1741,7 @@ impl Renderer {
self.queue
.write_buffer(&self.border_uniform, 0, bytemuck::bytes_of(&uniform));
}
let view_target = surface_frame
.texture
.create_view(&wgpu::TextureViewDescriptor {
let view_target = target_texture.create_view(&wgpu::TextureViewDescriptor {
format: Some(self.config.format.remove_srgb_suffix()),
..Default::default()
});
@@ -1661,6 +1750,9 @@ impl Renderer {
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Horizon frame"),
});
if let Some(timer) = &mut self.gpu_timer {
timer.begin(&mut encoder);
}
{
let attachments = [Some(wgpu::RenderPassColorAttachment {
view: &view_target,
@@ -1861,22 +1953,44 @@ impl Renderer {
frame.hud,
[self.config.width, self.config.height],
);
if let Some(timer) = &mut self.gpu_timer {
timer.end(&mut encoder);
}
let readback = self
.screenshot
.take()
.map(|path| (path, self.copy_frame(&mut encoder, &surface_frame.texture)));
self.queue.submit([encoder.finish()]);
.map(|path| (path, self.copy_frame(&mut encoder, &target_texture)));
let submission = self.queue.submit([encoder.finish()]);
if let Some(timer) = &mut self.gpu_timer {
timer.submitted();
timer.collect(&self.device, &mut self.gpu_times);
}
if let Some((path, buffer)) = readback {
self.screenshot_result = Some(
self.write_screenshot(&path, &buffer)
.map_err(|e| e.to_string()),
);
}
self.window.pre_present_notify();
self.queue.present(surface_frame);
if reconfigure {
self.surface.configure(&self.device, &self.config);
let present = Instant::now();
if let Some(surface_frame) = surface_frame {
self.window.pre_present_notify();
self.queue.present(surface_frame);
if reconfigure && let Some(surface) = &self.surface {
surface.configure(&self.device, &self.config);
}
} else {
// No swapchain paces offscreen frames: keep two on the GPU at most.
self.in_flight.push_back(submission);
while self.in_flight.len() > 2 {
let index = self.in_flight.pop_front();
let _ = self.device.poll(wgpu::PollType::Wait {
submission_index: index,
timeout: Some(std::time::Duration::from_secs(5)),
});
}
}
self.last_wait += present.elapsed();
self.last_encode = started.elapsed().saturating_sub(self.last_wait);
let _ = self.started;
Ok(true)
}
+122
View File
@@ -0,0 +1,122 @@
//! GPU frame time from timestamp queries, read back a few frames late so the
//! CPU never waits for it. Frames whose readback slot is still busy go untimed.
use std::sync::{
Arc,
atomic::{AtomicU8, Ordering},
};
const SLOTS: usize = 4;
const FREE: u8 = 0;
const PENDING: u8 = 1;
const MAPPED: u8 = 2;
struct Slot {
buffer: wgpu::Buffer,
state: Arc<AtomicU8>,
}
pub struct GpuTimer {
queries: wgpu::QuerySet,
resolve: wgpu::Buffer,
slots: Vec<Slot>,
/// The slot this frame writes into, when one was free at `begin`.
current: Option<usize>,
next: usize,
period_ns: f32,
}
impl GpuTimer {
/// The features timing needs; `None` when the adapter lacks them.
pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
let wanted =
wgpu::Features::TIMESTAMP_QUERY | wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS;
if adapter.features().contains(wanted) {
wanted
} else {
wgpu::Features::empty()
}
}
pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Option<Self> {
if !device
.features()
.contains(wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS)
{
return None;
}
let queries = device.create_query_set(&wgpu::QuerySetDescriptor {
label: Some("Frame timestamps"),
ty: wgpu::QueryType::Timestamp,
count: 2,
});
let resolve = device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Frame timestamp resolve"),
size: 16,
usage: wgpu::BufferUsages::QUERY_RESOLVE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let slots = (0..SLOTS)
.map(|_| Slot {
buffer: device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Frame timestamp readback"),
size: 16,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
}),
state: Arc::new(AtomicU8::new(FREE)),
})
.collect();
Some(Self {
queries,
resolve,
slots,
current: None,
next: 0,
period_ns: queue.get_timestamp_period(),
})
}
pub fn begin(&mut self, encoder: &mut wgpu::CommandEncoder) {
let slot = self.next;
self.current = (self.slots[slot].state.load(Ordering::Acquire) == FREE).then_some(slot);
if self.current.is_some() {
encoder.write_timestamp(&self.queries, 0);
}
}
pub fn end(&mut self, encoder: &mut wgpu::CommandEncoder) {
let Some(slot) = self.current else { return };
encoder.write_timestamp(&self.queries, 1);
encoder.resolve_query_set(&self.queries, 0..2, &self.resolve, 0);
encoder.copy_buffer_to_buffer(&self.resolve, 0, &self.slots[slot].buffer, 0, 16);
}
/// After the frame's submission: start reading its timestamps back.
pub fn submitted(&mut self) {
let Some(slot) = self.current.take() else {
return;
};
let state = self.slots[slot].state.clone();
state.store(PENDING, Ordering::Release);
self.slots[slot]
.buffer
.slice(..)
.map_async(wgpu::MapMode::Read, move |result| {
state.store(if result.is_ok() { MAPPED } else { FREE }, Ordering::Release);
});
self.next = (slot + 1) % SLOTS;
}
/// GPU milliseconds of frames whose timestamps have arrived, oldest first.
pub fn collect(&mut self, device: &wgpu::Device, out: &mut Vec<f32>) {
let _ = device.poll(wgpu::PollType::Poll);
for i in 0..SLOTS {
let slot = &self.slots[(self.next + i) % SLOTS];
if slot.state.load(Ordering::Acquire) != MAPPED {
continue;
}
if let Ok(data) = slot.buffer.slice(..).get_mapped_range() {
let stamps: &[u64] = bytemuck::cast_slice(&data);
let ticks = stamps[1].saturating_sub(stamps[0]);
out.push((ticks as f64 * f64::from(self.period_ns) / 1e6) as f32);
}
slot.buffer.unmap();
slot.state.store(FREE, Ordering::Release);
}
}
}
+163
View File
@@ -0,0 +1,163 @@
#!/usr/bin/env python3
"""Repeatable graphics benchmark for the native client.
Opens a fresh seeded creative world on a virtual screen (vscreen) and flies the
camera along fixed straight paths over a village, a forest, the ocean and a
mountain, at render distances 8, 16 and 32. Each flight replies with frame
times (average FPS, 1% lows, percentiles), the CPU part of each frame and the
GPU time from timestamp queries.
python3 tools/graphics_bench.py --label baseline
python3 tools/graphics_bench.py --label baseline --offscreen # the discrete GPU
`--offscreen` renders into a texture instead of the window, so the desktop's
GPU can be measured even though the headless compositor (vscreen) only
presents software-rendered (lavapipe) frames. Without it, frame times on
vscreen are lavapipe's: use them for CPU-side numbers.
"""
import argparse
import datetime
import json
import os
import shutil
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
SEED = "1234"
WORLD = "GraphicsBench"
# (name, from xyz, to xyz, pitch): straight flights at a constant speed over
# fixed scenery of seed 1234. Each path is 192 blocks long.
SCENES = [
("village", (-960.0, 125.0, 80.0), (-960.0, 125.0, 272.0), 35.0),
("forest", (-1100.0, 120.0, -560.0), (-1100.0, 120.0, -368.0), 25.0),
("ocean", (-300.0, 85.0, -420.0), (-300.0, 85.0, -228.0), 10.0),
("mountain", (560.0, 260.0, 860.0), (752.0, 260.0, 860.0), 30.0),
]
OPTIONS = """version:4790
enableVsync:false
maxFps:260
renderDistance:{distance}
simulationDistance:12
fov:0.0
guiScale:0
"""
def vscreen_env():
out = subprocess.run(["vscreen", "env"], cwd=ROOT, capture_output=True, text=True, check=True)
env = dict(os.environ)
for part in out.stdout.replace(";", " ").split():
if "=" in part and not part.startswith("export"):
k, v = part.split("=", 1)
env[k] = v
env.pop("DISPLAY", None)
return env
class Game:
def __init__(self, ctl, socket, env, cwd):
self.ctl, self.socket, self.env, self.cwd = ctl, socket, env, cwd
def run(self, *words, check=True):
out = subprocess.run(
[str(self.ctl), "--socket", str(self.socket), *map(str, words)],
cwd=self.cwd, env=self.env, capture_output=True, text=True,
)
line = out.stdout.strip().splitlines()[-1] if out.stdout.strip() else "{}"
reply = json.loads(line) if line.startswith("{") else {"error": out.stderr.strip()}
if check and "error" in reply:
raise RuntimeError(f"{' '.join(map(str, words))}: {reply} {out.stderr.strip()}")
return reply
def run_distance(args, ctl, env, cwd, distance):
(cwd / "options.txt").write_text(OPTIONS.format(distance=distance))
socket = cwd / "control.sock"
game = Game(ctl, socket, env, cwd)
launch = [
"launch", "--world", WORLD, "--seed", SEED, "--creative",
"--render-distance", distance, "--resources", args.resources,
"--no-pause", "--weather", "clear", "--time", "6000",
]
if args.offscreen:
launch.append("--offscreen")
game.run(*launch)
results = {}
try:
game.run("wait-ready", 300)
status = game.run("status")
results["renderer"] = status.get("renderer")
for name, start, end, pitch in SCENES:
if args.scenes and name not in args.scenes.split(","):
continue
game.run("tp", *start)
game.run("look", 0, pitch)
game.run("time", 6000)
game.run("wait-ready", 300)
time.sleep(args.settle)
summary = game.run("fly", *start, *end, args.seconds, pitch)
results[name] = summary
print(
f" rd {distance:>2} {name:<9} {summary.get('avg_fps', 0):7.1f} fps"
f" 1% low {summary.get('low_1pct_fps', 0):7.1f}"
f" p99 {summary.get('p99_ms', 0):6.2f} ms"
f" cpu {((summary.get('cpu') or {}).get('avg_ms') or 0):6.2f} ms"
f" gpu {((summary.get('gpu') or {}).get('avg_ms') or 0):6.2f} ms"
+ " [" + " ".join(f"{k} {v:.2f}" for k, v in (summary.get("phases_avg_ms") or {}).items()) + "]",
flush=True,
)
finally:
game.run("quit", check=False)
for _ in range(100):
if not socket.exists():
break
time.sleep(0.2)
return results
def main():
p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
p.add_argument("--label", default="run")
p.add_argument("--distances", default="8,16,32")
p.add_argument("--scenes", help="comma-separated subset of " + ",".join(s[0] for s in SCENES))
p.add_argument("--seconds", type=float, default=12.0, help="flight duration per scene")
p.add_argument("--settle", type=float, default=2.0, help="seconds to wait before each flight")
p.add_argument("--offscreen", action="store_true", help="render offscreen on the discrete GPU")
p.add_argument("--resources", default=str(ROOT / ".local/horizon-client/26.3"))
p.add_argument("--build", default=str(ROOT / "target/release"))
p.add_argument("--out", help="JSON file (default benchmarks/graphics/<label>.json)")
args = p.parse_args()
ctl = Path(args.build) / "horizon-ctl"
if not ctl.exists():
sys.exit(f"{ctl} missing: cargo build --release -p horizon-client --bins")
cwd = ROOT / ".local/graphics-bench"
shutil.rmtree(cwd / "saves" / WORLD, ignore_errors=True)
cwd.mkdir(parents=True, exist_ok=True)
env = vscreen_env()
subprocess.run(["vscreen", "up"], cwd=ROOT, check=True, capture_output=True)
commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT,
capture_output=True, text=True).stdout.strip()
report = {
"label": args.label,
"date": datetime.date.today().isoformat(),
"commit": commit,
"host": os.uname().nodename,
"offscreen": args.offscreen,
"seed": SEED,
"flight_seconds": args.seconds,
"scenes": {n: {"from": a, "to": b, "pitch": c} for n, a, b, c in SCENES},
"distances": {},
}
for d in [int(x) for x in args.distances.split(",")]:
report["distances"][str(d)] = run_distance(args, ctl, env, cwd, d)
out = Path(args.out) if args.out else ROOT / "benchmarks/graphics" / f"{args.label}.json"
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(report, indent=2) + "\n")
print(out)
if __name__ == "__main__":
main()