[{"benchmark_id":"app:static_web","name":"Static web server","description":"Serving smaller (1-65 kb) and larger (256-512 kb) files using a static HTTP server (binserve), and benchmarking each workload (wrk) using variable number of threads and connections on the same server.","framework":"app","measurement":"static_web","unit":"rps","higher_is_better":true,"status":"INACTIVE","configs":{"threads":{"description":"Total number of threads used by wrk.","examples":[]},"connections":{"description":"Total number of HTTP connections kept open by wrk.","examples":[]},"framework_version":{"description":"Version number of both binserve and wrk.","examples":[]}},"count":0,"count_servers":0,"histogram":null},{"benchmark_id":"bogomips","name":"BogoMips","description":"A crude measurement of CPU speed by the Linux kernel. This is NOT usable for performance comparisons among different CPUs, but might be useful to check if a processor is in the range of similar processors. As often quoted, BogoMips measures \"the number of million times per second a processor can do absolutely nothing\".","framework":"bogomips","measurement":null,"unit":"Millions of instructions per second (MIPS)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3742,"count_servers":3742,"histogram":{"breakpoints":[50.0,447.5,845.0,1242.5,1640.0,2037.5,2435.0,2832.5,3230.0,3627.5,4025.0,4422.5,4820.0,5217.5,5615.0,6012.5,6410.0,6807.5,7205.0,7602.5,8000.0],"counts":[200,0,0,0,264,66,0,0,6,36,178,555,1212,623,339,87,148,0,26,2]}},{"benchmark_id":"bw_mem","name":"Memory bandwidth (bw_mem)","description":"bw_mem allocates twice the specified amount of memory, zeros it, and then times the copying of the first half to the second half. Results are reported in megabytes moved per second (MB/sec). bw_mem is provided by lmbench. For more details, see the man pages.","framework":"bw_mem","measurement":null,"unit":"Megabytes per second (MB/sec)","higher_is_better":true,"status":"ACTIVE","configs":{"size":{"description":"Amount of memory to be used in MB","examples":[0.016384,0.262144,1.0,2.0,4.0,8.0,16.0,32.0,64.0,256.0,512.0]},"operation":{"description":"The type of measurement: 'rd' measures the time to read data into the processor, 'wr' measures the time to write data to memory, and 'rdwr' measures the time to read data into memory and then write data to the same memory location.","examples":["rd","rdwr","wr"]}},"count":120494,"count_servers":3654,"histogram":{"breakpoints":[100.43,1979136.6354999999,3958172.841,5937209.046499999,7916245.251999999,9895281.4575,11874317.662999999,13853353.8685,15832390.074,17811426.2795,19790462.485,21769498.6905,23748534.895999998,25727571.101499997,27706607.307,29685643.5125,31664679.718,33643715.9235,35622752.129,37601788.3345,39580824.54],"counts":[110906,5207,2109,914,473,375,123,111,86,52,44,49,11,6,10,9,1,6,1,1]}},{"benchmark_id":"compression_text:compress","name":"Compression bandwidth","description":"Measures the compression bandwidth (bytes/second) on the dickens.txt of the Silesia corpus (10 MB uncompressed) using various algorithms, compression levels and other extra arguments.","framework":"compression_text","measurement":"compress","unit":"Bytes per second (Bps)","higher_is_better":true,"status":"ACTIVE","configs":{"algo":{"description":"Compression algorithm, e.g. brotli or bz2.","examples":["brotli","bzip2","bzip3","gzip","lz4","lzma","zpaq","zstd"]},"cores":{"description":"Single-Core or Multi-Core compression tests.","examples":["multi","single"]},"block_size":{"description":"Block size","examples":[65536,1048576,4194304,67108864]},"compression_level":{"description":"Compression level/quality/level.","examples":[0,1,3,4,5,6,7,8,9,11,12,14,16,22]}},"count":195310,"count_servers":3643,"histogram":{"breakpoints":[74248.77163730914,3402526999.6536746,6804979750.535711,10207432501.417747,13609885252.299786,17012338003.181824,20414790754.063858,23817243504.945896,27219696255.827934,30622149006.709972,34024601757.59201,37427054508.474045,40829507259.35608,44231960010.23812,47634412761.120155,51036865512.0022,54439318262.88423,57841771013.766266,61244223764.64831,64646676515.53034,68049129266.412384],"counts":[189993,2409,1024,610,443,317,109,137,92,37,21,29,10,24,18,12,4,14,6,1]}},{"benchmark_id":"compression_text:decompress","name":"Decompression bandwidth","description":"Measures the decompression bandwidth (bytes/second) on the compressed dickens.txt of the Silesia corpus (10 MB uncompressed) using various algorithms, compression levels and other extra arguments.","framework":"compression_text","measurement":"decompress","unit":"Bytes per second (Bps)","higher_is_better":true,"status":"ACTIVE","configs":{"algo":{"description":"Compression algorithm, e.g. brotli or bz2.","examples":["brotli","bzip2","bzip3","gzip","lz4","lzma","zpaq","zstd"]},"cores":{"description":"Single-Core or Multi-Core compression tests.","examples":["multi","single"]},"block_size":{"description":"Block size","examples":[65536,1048576,4194304,67108864]},"compression_level":{"description":"Compression level/quality/level.","examples":[0,1,3,4,5,6,7,8,9,11,12,14,16,22]}},"count":195310,"count_servers":3643,"histogram":{"breakpoints":[74133.0836284516,12712341993.446295,25424609853.808964,38136877714.17162,50849145574.534294,63561413434.896965,76273681295.25963,88985949155.6223,101698217015.98497,114410484876.34764,127122752736.71031,139835020597.07297,152547288457.4356,165259556317.79828,177971824178.16095,190684092038.52362,203396359898.8863,216108627759.24896,228820895619.61163,241533163479.9743,254245431340.33698],"counts":[183388,7011,2346,1084,534,314,187,130,104,54,57,38,23,18,10,7,3,1,0,1]}},{"benchmark_id":"compression_text:ratio","name":"Compression ratio","description":"Measures the compression ratio while compressing the dickens.txt of the Silesia corpus (10 MB uncompressed) using various algorithms, compression levels and other extra arguments.","framework":"compression_text","measurement":"ratio","unit":null,"higher_is_better":false,"status":"ACTIVE","configs":{"algo":{"description":"Compression algorithm, e.g. brotli or bz2.","examples":["brotli","bzip2","bzip3","gzip","lz4","lzma","zpaq","zstd"]},"cores":{"description":"Single-Core or Multi-Core compression tests.","examples":["multi","single"]},"block_size":{"description":"Block size","examples":[65536,1048576,4194304,67108864]},"compression_level":{"description":"Compression level/quality/level.","examples":[0,1,3,4,5,6,7,8,9,11,12,14,16,22]}},"count":195310,"count_servers":3643,"histogram":{"breakpoints":[21.024737339790665,23.12782132963962,25.23090531948857,27.333989309337525,29.43707329918648,31.54015728903543,33.64324127888439,35.74632526873334,37.84940925858229,39.952493248431246,42.05557723828019,44.15866122812915,46.2617452179781,48.36482920782706,50.46791319767601,52.570997187524966,54.67408117737392,56.777165167222876,58.88024915707183,60.98333314692077,63.086417136769725],"counts":[11395,6888,0,34819,17377,12475,5587,16076,5587,6888,55870,5587,0,0,0,0,0,0,0,16761]}},{"benchmark_id":"geekbench:asset_compression","name":"Geekbench: Asset Compression","description":"Compresses 16 texture images and geometry files using ASTC, BC7, DXTC, and Draco.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"asset_compression","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[334.0,4243.65,8153.3,12062.95,15972.6,19882.25,23791.9,27701.55,31611.2,35520.85,39430.5,43340.15,47249.8,51159.450000000004,55069.1,58978.75,62888.4,66798.05,70707.7,74617.35,78527.0],"counts":[4082,477,299,264,222,234,207,191,219,164,128,89,60,40,24,34,7,12,4,1]}},{"benchmark_id":"geekbench:background_blur","name":"Geekbench: Background Blur","description":"Separates and blurs the background of 10 frames in a 1080p video, using DeepLabV3+.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"background_blur","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[219.0,1487.4,2755.8,4024.2000000000003,5292.6,6561.0,7829.400000000001,9097.800000000001,10366.2,11634.6,12903.0,14171.400000000001,15439.800000000001,16708.2,17976.600000000002,19245.0,20513.4,21781.800000000003,23050.2,24318.600000000002,25587.0],"counts":[1030,2122,888,326,311,487,365,278,285,193,199,72,74,32,33,23,20,6,3,11]}},{"benchmark_id":"geekbench:clang","name":"Geekbench: Clang","description":"Compiles files (8 in single-core mode, 96 in multi-core mode) of the Lua interpreter using Clang and the musl libc as the C standard library for the compiled files.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"clang","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[402.0,6357.3,12312.6,18267.9,24223.2,30178.5,36133.8,42089.1,48044.4,53999.700000000004,59955.0,65910.3,71865.6,77820.90000000001,83776.2,89731.5,95686.8,101642.1,107597.40000000001,113552.7,119508.0],"counts":[4267,521,347,287,219,162,212,154,144,150,69,74,39,26,41,35,6,3,1,1]}},{"benchmark_id":"geekbench:file_compression","name":"Geekbench: File Compression","description":"Compresses and decompresses the Ruby 3.1.2 source archive (a 75 MB archive with 9841 files) using LZ4 and ZSTD on an in-memory encrypted file system. It also verifies the files using SHA1.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"file_compression","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[298.0,1272.85,2247.7,3222.55,4197.4,5172.25,6147.1,7121.95,8096.8,9071.65,10046.5,11021.35,11996.2,12971.050000000001,13945.9,14920.75,15895.6,16870.45,17845.3,18820.15,19795.0],"counts":[1353,2397,522,332,305,248,229,225,200,164,242,192,132,94,43,25,24,15,13,3]}},{"benchmark_id":"geekbench:hdr","name":"Geekbench: HDR","description":"Blends six 16MP SDR photos to create a single HDR photo, using a recovery process and radiance map construction (Debevec and Malik 1997), and a tone mapping algorithm (Reinhard and Devlin 2005).The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"hdr","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[375.0,2089.15,3803.3,5517.450000000001,7231.6,8945.75,10659.900000000001,12374.050000000001,14088.2,15802.35,17516.5,19230.65,20944.800000000003,22658.95,24373.100000000002,26087.25,27801.4,29515.550000000003,31229.7,32943.850000000006,34658.0],"counts":[3284,848,335,399,289,322,281,325,190,127,82,82,56,56,23,18,18,6,13,4]}},{"benchmark_id":"geekbench:horizon_detection","name":"Geekbench: Horizon Detection","description":"Detects and straightens uneven or crooked horizon lines in a 48MP photo to make it look more realistic, using the Canny edge detector and the Hough transform.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"horizon_detection","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[435.0,3297.2,6159.4,9021.599999999999,11883.8,14746.0,17608.199999999997,20470.399999999998,23332.6,26194.8,29057.0,31919.199999999997,34781.399999999994,37643.6,40505.799999999996,43368.0,46230.2,49092.399999999994,51954.6,54816.799999999996,57679.0],"counts":[3821,475,328,305,223,220,237,183,158,185,175,122,102,60,60,37,18,40,7,2]}},{"benchmark_id":"geekbench:html5_browser","name":"Geekbench: HTML5 Browser","description":"Opens and renders web pages (8 in single-core mode, 32 in multi-core mode) using a headless web browser.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"html5_browser","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[370.0,2716.65,5063.3,7409.950000000001,9756.6,12103.25,14449.900000000001,16796.55,19143.2,21489.850000000002,23836.5,26183.15,28529.800000000003,30876.45,33223.1,35569.75,37916.4,40263.05,42609.700000000004,44956.35,47303.0],"counts":[3668,571,355,293,274,247,241,305,249,166,110,57,22,54,24,34,38,45,2,3]}},{"benchmark_id":"geekbench:navigation","name":"Geekbench: Navigation","description":"Generates 24 different routes between a sequence of locations on two OpenStreetMap maps (one for a small city, one for a large city) using Dijkstra's algorithm.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"navigation","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[358.0,1791.0,3224.0,4657.0,6090.0,7523.0,8956.0,10389.0,11822.0,13255.0,14688.0,16121.0,17554.0,18987.0,20420.0,21853.0,23286.0,24719.0,26152.0,27585.0,29018.0],"counts":[2825,1072,285,188,215,169,142,217,172,221,216,254,270,197,125,103,30,28,21,8]}},{"benchmark_id":"geekbench:object_detection","name":"Geekbench: Object Detection","description":"Detects and classifies objects in 300x300 pixel photos (16 in single-core mode, 64 in multi-core mode) using the MobileNet v1 SSD convolutional neural network.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"object_detection","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[50.0,1283.9,2517.8,3751.7000000000003,4985.6,6219.5,7453.400000000001,8687.300000000001,9921.2,11155.1,12389.0,13622.900000000001,14856.800000000001,16090.7,17324.600000000002,18558.5,19792.4,21026.300000000003,22260.2,23494.100000000002,24728.0],"counts":[1936,1507,1012,335,249,286,252,284,153,121,155,184,69,54,42,40,45,23,7,4]}},{"benchmark_id":"geekbench:object_remover","name":"Geekbench: Object Remover","description":"Removes an object (using a mask) from a 3MP photo, and fills in the gap left behind using the iterative PatchMatch Inpainting approach (Barnes et al. 2009).The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"object_remover","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[247.0,1864.3,3481.6,5098.9,6716.2,8333.5,9950.8,11568.1,13185.4,14802.699999999999,16420.0,18037.3,19654.6,21271.899999999998,22889.2,24506.5,26123.8,27741.1,29358.399999999998,30975.7,32593.0],"counts":[3045,1071,318,328,284,290,260,256,210,219,177,87,58,51,42,20,19,7,10,6]}},{"benchmark_id":"geekbench:pdf_renderer","name":"Geekbench: PDF Renderer","description":"Opens complex PDF documents (4 in single-core mode, 16 in multi-core mode) of park maps from the American National Park Service (sizes from 897 kB to 1.5 MB) with large vector images, lines and text.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"pdf_renderer","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[364.0,1855.25,3346.5,4837.75,6329.0,7820.25,9311.5,10802.75,12294.0,13785.25,15276.5,16767.75,18259.0,19750.25,21241.5,22732.75,24224.0,25715.25,27206.5,28697.75,30189.0],"counts":[2493,1384,302,192,267,266,194,276,188,182,354,199,169,58,107,39,27,28,15,18]}},{"benchmark_id":"geekbench:photo_filter","name":"Geekbench: Photo Filter","description":"Applies colour and blur filters, level adjustments, cropping, scaling, and image compositing filters to 10 photos that range in size from 3 MP to 15 MP.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"photo_filter","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[246.0,1707.4,3168.8,4630.200000000001,6091.6,7553.0,9014.400000000001,10475.800000000001,11937.2,13398.6,14860.0,16321.400000000001,17782.800000000003,19244.2,20705.600000000002,22167.0,23628.4,25089.800000000003,26551.2,28012.600000000002,29474.0],"counts":[1958,1993,314,285,330,333,298,308,308,180,143,94,80,47,17,33,14,7,8,8]}},{"benchmark_id":"geekbench:photo_library","name":"Geekbench: Photo Library","description":"Categorizes and tags photos (16 in single-core mode, 64 in multi-core mode) based on the objects that they contain. The workload performs JPEG decompression, thumbnail generation, image transformations, image classification (using MobileNet 1.0), and storing data in SQLite.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"photo_library","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[204.0,3296.7,6389.4,9482.099999999999,12574.8,15667.5,18760.199999999997,21852.899999999998,24945.6,28038.3,31131.0,34223.7,37316.399999999994,40409.1,43501.799999999996,46594.5,49687.2,52779.899999999994,55872.6,58965.299999999996,62058.0],"counts":[4002,493,343,329,205,262,206,158,205,146,118,111,50,36,36,28,9,8,7,6]}},{"benchmark_id":"geekbench:ray_tracer","name":"Geekbench: Ray Tracer","description":"Renders the Blender BMW scene using a custom ray tracer built with the Intel Embree ray tracing library.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"ray_tracer","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[349.0,13801.65,27254.3,40706.95,54159.6,67612.25,81064.9,94517.55,107970.2,121422.84999999999,134875.5,148328.15,161780.8,175233.44999999998,188686.1,202138.75,215591.4,229044.05,242496.69999999998,255949.35,269402.0],"counts":[4866,529,326,284,203,112,134,97,34,50,53,28,8,10,9,7,3,1,1,3]}},{"benchmark_id":"geekbench:score","name":"Geekbench: Score","description":"Composite score using the weighted arithmetic mean of the subsection scores, which are computed using the geometric mean of the related scores.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[334.0,1971.9,3609.8,5247.700000000001,6885.6,8523.5,10161.400000000001,11799.300000000001,13437.2,15075.1,16713.0,18350.9,19988.800000000003,21626.7,23264.600000000002,24902.5,26540.4,28178.300000000003,29816.2,31454.100000000002,33092.0],"counts":[2877,1221,277,313,248,274,212,206,171,230,200,104,178,84,43,56,21,21,15,7]}},{"benchmark_id":"geekbench:structure_from_motion","name":"Geekbench: Structure from Motion","description":"Generates 3D geometry by constructing the coordinates of the points that are visible in nine 2D images of the same scene.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"structure_from_motion","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[240.0,3516.65,6793.3,10069.95,13346.6,16623.25,19899.9,23176.55,26453.2,29729.850000000002,33006.5,36283.15,39559.8,42836.450000000004,46113.1,49389.75,52666.4,55943.05,59219.700000000004,62496.35,65773.0],"counts":[3930,458,390,315,272,257,240,260,196,146,90,48,50,36,26,12,27,1,3,1]}},{"benchmark_id":"geekbench:text_processing","name":"Geekbench: Text Processing","description":"Loads 190 markdown files, parses the contents using regular expressions, stores metadata in a SQLite database, and exports the content to a different format on an in-memory encrypted file system, using a mix of C++ and Python.The score is calibrated against a baseline score of 2,500 (Dell Precision 3460 with a Core i7-12700 processor) as per the Geekbench 6 Benchmark Internals.","framework":"geekbench","measurement":"text_processing","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core performance tests.","examples":["multi","single"]}},"count":6758,"count_servers":3379,"histogram":{"breakpoints":[346.0,569.05,792.1,1015.1500000000001,1238.2,1461.25,1684.3000000000002,1907.3500000000001,2130.4,2353.45,2576.5,2799.55,3022.6000000000004,3245.65,3468.7000000000003,3691.75,3914.8,4137.85,4360.9,4583.95,4807.0],"counts":[34,76,473,930,709,1077,611,980,709,318,355,265,55,36,43,60,12,12,0,3]}},{"benchmark_id":"llm_speed:prompt_processing","name":"LLM inference speed for prompt processing","description":"Running llama-bench from llama.cpp using various quantized model files to measure the speed of processing 16 to 16k tokens.","framework":"llm_speed","measurement":"prompt_processing","unit":"tokens/second (t/s)","higher_is_better":true,"status":"ACTIVE","configs":{"model":{"description":"Name of the model file used.","examples":["Llama-3.3-70B-Instruct-Q4_K_M.gguf","SmolLM-135M.Q4_K_M.gguf","gemma-2b.Q4_K_M.gguf","llama-7b.Q4_K_M.gguf","phi-4-q4.gguf","qwen1_5-0_5b-chat-q4_k_m.gguf"]},"tokens":{"description":"Number of tokens processed in one run.","examples":[16,128,512,1024,4096,16384]}},"count":63925,"count_servers":3453,"histogram":{"breakpoints":[0.539014,5144.81794465,10289.0968753,15433.37580595,20577.6547366,25721.93366725,30866.2125979,36010.49152855,41154.7704592,46299.04938985,51443.3283205,56587.60725115,61731.8861818,66876.16511244999,72020.4440431,77164.72297374999,82309.0019044,87453.28083505,92597.55976569999,97741.83869635,102886.11762699999],"counts":[61693,794,382,145,200,196,131,122,80,75,45,25,15,8,7,2,4,0,0,1]}},{"benchmark_id":"llm_speed:text_generation","name":"LLM inference speed for text generation","description":"Running llama-bench from llama.cpp using various quantized model files to measure the speed of generating 16 to 4k tokens.","framework":"llm_speed","measurement":"text_generation","unit":"tokens/second (t/s)","higher_is_better":true,"status":"ACTIVE","configs":{"model":{"description":"Name of the model file used.","examples":["Llama-3.3-70B-Instruct-Q4_K_M.gguf","SmolLM-135M.Q4_K_M.gguf","gemma-2b.Q4_K_M.gguf","llama-7b.Q4_K_M.gguf","phi-4-q4.gguf","qwen1_5-0_5b-chat-q4_k_m.gguf"]},"tokens":{"description":"Number of tokens processed in one run.","examples":[16,128,512,1024,4096]}},"count":48591,"count_servers":3450,"histogram":{"breakpoints":[0.376574,35.271227499999995,70.165881,105.06053449999999,139.955188,174.8498415,209.74449499999997,244.63914849999998,279.533802,314.4284555,349.323109,384.2177625,419.11241599999994,454.00706949999994,488.90172299999995,523.7963765,558.69103,593.5856835,628.480337,663.3749905,698.269644],"counts":[18210,9423,5913,3918,2661,1984,1652,1497,1322,801,457,338,190,91,54,34,24,10,9,3]}},{"benchmark_id":"membench:bandwidth_copy","name":"Memory copy bandwidth (sc-membench)","description":"Measures aggregate memory copy bandwidth across all threads using OpenMP parallelization.","framework":"membench","measurement":"memory_bandwidth","unit":"MB/s","higher_is_better":true,"status":"ACTIVE","configs":{"scope":{"description":"RAM: working set exceeds total CPU cache (L3, else L2, else L1d).","examples":["RAM"]},"size_kb":{"description":"Per-thread buffer size in KiB.","examples":[16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152]}},"count":25660,"count_servers":2393,"histogram":{"breakpoints":[940.8,853676.2205,1706411.641,2559147.0615,3411882.482,4264617.9025,5117353.323,5970088.7435,6822824.164,7675559.5845,8528295.005,9381030.425500002,10233765.846,11086501.2665,11939236.687,12791972.107500002,13644707.528,14497442.9485,15350178.369,16202913.789500002,17055649.21],"counts":[23408,1233,535,196,132,46,24,31,20,6,13,1,1,1,1,6,0,0,3,3]}},{"benchmark_id":"membench:bandwidth_read","name":"Memory read bandwidth (sc-membench)","description":"Measures aggregate sequential read bandwidth across all threads using OpenMP parallelization.","framework":"membench","measurement":"memory_bandwidth","unit":"MB/s","higher_is_better":true,"status":"ACTIVE","configs":{"scope":{"description":"RAM: working set exceeds total CPU cache (L3, else L2, else L1d).","examples":["RAM"]},"size_kb":{"description":"Per-thread buffer size in KiB.","examples":[16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152]}},"count":25660,"count_servers":2393,"histogram":{"breakpoints":[1890.35,1854173.012,3706455.674,5558738.335999999,7411020.998,9263303.66,11115586.321999999,12967868.984,14820151.646,16672434.308,18524716.970000003,20376999.632000003,22229282.294,24081564.956,25933847.618,27786130.28,29638412.942,31490695.604000002,33342978.266000003,35195260.928,37047543.59],"counts":[23300,1440,494,226,74,35,16,37,19,6,8,2,0,1,1,0,0,0,0,1]}},{"benchmark_id":"membench:bandwidth_write","name":"Memory write bandwidth (sc-membench)","description":"Measures aggregate sequential write bandwidth across all threads using OpenMP parallelization.","framework":"membench","measurement":"memory_bandwidth","unit":"MB/s","higher_is_better":true,"status":"ACTIVE","configs":{"scope":{"description":"RAM: working set exceeds total CPU cache (L3, else L2, else L1d).","examples":["RAM"]},"size_kb":{"description":"Per-thread buffer size in KiB.","examples":[16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152]}},"count":25660,"count_servers":2393,"histogram":{"breakpoints":[1683.49,2029468.9775,4057254.4650000003,6085039.952500001,8112825.44,10140610.9275,12168396.415000001,14196181.9025,16223967.39,18251752.877499998,20279538.365,22307323.8525,24335109.34,26362894.8275,28390680.314999998,30418465.8025,32446251.29,34474036.7775,36501822.265,38529607.752500005,40557393.24],"counts":[24104,977,351,94,70,17,15,5,4,19,2,0,0,1,0,0,0,0,0,1]}},{"benchmark_id":"membench:latency","name":"Memory latency (sc-membench)","description":"Measures median memory latency using pointer chasing with randomized access to defeat hardware prefetching.","framework":"membench","measurement":"memory_latency","unit":"ns","higher_is_better":false,"status":"ACTIVE","configs":{"scope":{"description":"RAM: working set exceeds total CPU cache (L3, else L2, else L1d).","examples":["RAM"]},"size_kb":{"description":"Per-thread buffer size in KiB.","examples":[16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,2097152]}},"count":25660,"count_servers":2393,"histogram":{"breakpoints":[0.73,43.724999999999994,86.72,129.71499999999997,172.70999999999998,215.70499999999998,258.7,301.695,344.69,387.685,430.68,473.675,516.67,559.665,602.66,645.655,688.65,731.645,774.64,817.635,860.63],"counts":[16234,3200,4930,1006,161,52,50,8,7,2,4,1,1,0,0,0,3,0,0,1]}},{"benchmark_id":"nvbandwidth:all:duplex","name":"Node baseline directional bandwidth (nvbandwidth)","description":"Conservative per-direction bandwidth (GB/s) under simultaneous bi-directional saturation utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[5.253345649,13.91861034715,22.5838750453,31.24913974345,39.9144044416,48.579669139749996,57.24493383790001,65.91019853605,74.5754632342,83.24072793235,91.9059926305,100.57125732865,109.2365220268,117.90178672495,126.56705142310001,135.23231612125002,143.89758081940002,152.56284551755002,161.2281102157,169.89337491385,178.558639612],"counts":[75,30,17,7,21,7,3,3,2,3,5,1,0,0,0,1,1,2,0,2]}},{"benchmark_id":"nvbandwidth:all:gpu_to_host","name":"Node GPU-to-host bandwidth (nvbandwidth)","description":"Total node egress rate (GB/s) when ALL GPUs stream to CPU concurrently utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[6.587231709,17.7241316683,28.8610316276,39.9979315869,51.1348315462,62.27173150549999,73.4086314648,84.54553142409999,95.68243138339999,106.81933134269998,117.95623130199998,129.0931312613,140.2300312206,151.3669311799,162.5038311392,173.6407310985,184.7776310578,195.9145310171,207.05143097639998,218.18833093569998,229.32523089499998],"counts":[74,44,0,6,31,1,4,1,4,8,1,0,0,0,0,0,0,0,1,5]}},{"benchmark_id":"nvbandwidth:all:host_to_gpu","name":"Node host-to-GPU bandwidth (nvbandwidth)","description":"Total node ingest rate (GB/s) when CPU streams to ALL GPUs concurrently utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[6.214790729000001,17.34495148805,28.4751122471,39.60527300615,50.7354337652,61.86559452425,72.9957552833,84.12591604235,95.2560768014,106.38623756045,117.5163983195,128.64655907855,139.7767198376,150.90688059665,162.0370413557,173.16720211475,184.2973628738,195.42752363285,206.5576843919,217.68784515095,228.81800591],"counts":[74,44,0,9,28,0,2,0,4,12,0,0,0,1,0,0,0,0,0,6]}},{"benchmark_id":"nvbandwidth:efficiency:sm_ce_ratio","name":"SM/CE copy efficiency (nvbandwidth)","description":"Ratio (between 0.0 and 1.0) showing compute-core copy efficiency vs. raw DMA Copy Engine capacity, or in other terms, the ratio between CE (Copy Engine) and Streaming Multiprocessor (SM).","framework":"nvbandwidth","measurement":"gpu_efficiency","unit":"ratio","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[0.07174034600378562,0.11815332870359634,0.16456631140340705,0.21097929410321778,0.25739227680302845,0.3038052595028392,0.35021824220264997,0.3966312249024606,0.44304420760227137,0.489457190302082,0.5358701730018928,0.5822831557017035,0.6286961384015143,0.6751091211013249,0.7215221038011357,0.7679350865009463,0.8143480692007571,0.8607610519005678,0.9071740346003785,0.9535870173001892,0.9999999999999999],"counts":[4,2,0,2,1,0,0,1,4,0,3,15,4,3,3,2,3,3,26,104]}},{"benchmark_id":"nvbandwidth:p2p:duplex","name":"GPU-to-GPU P2P duplex bandwidth (nvbandwidth)","description":"Per-direction NVLink/P2P lane speed (GB/s) during simultaneous transfers in both directions between two GPUs utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":33,"count_servers":33,"histogram":{"breakpoints":[4.942396553250001,43.2134376076875,81.48447866212501,119.75551971656252,158.02656077100002,196.2976018254375,234.56864287987503,272.8396839343125,311.11072498875,349.3817660431875,387.652807097625,425.92384815206253,464.1948892065,502.4659302609375,540.7369713153751,579.0080123698125,617.27905342425,655.5500944786876,693.821135533125,732.0921765875626,770.363217642],"counts":[8,3,0,1,0,5,3,0,0,5,5,0,0,0,0,0,0,0,0,3]}},{"benchmark_id":"nvbandwidth:p2p:gather","name":"GPU-to-GPU P2P gather bandwidth (nvbandwidth)","description":"Intake bandwidth (GB/s) on a single target GPU when all peer GPUs send to it at once utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":33,"count_servers":33,"histogram":{"breakpoints":[9.393072465982693,48.68659257613226,87.98011268628184,127.27363279643141,166.567152906581,205.86067301673057,245.15419312688013,284.4477132370297,323.7412333471793,363.03475345732886,402.32827356747845,441.621793677628,480.91531378777756,520.2088338979271,559.5023540080766,598.7958741182263,638.0893942283758,677.3829143385253,716.676434448675,755.9699545588245,795.2634746689741],"counts":[4,5,2,0,0,0,8,0,0,11,0,0,0,0,0,0,0,0,0,3]}},{"benchmark_id":"nvbandwidth:p2p:latency","name":"GPU-to-GPU P2P latency (nvbandwidth)","description":"Direct transit latency (ns) between GPU pairs over NVLink/P2P utilizing SM (Streaming Multiprocessor).","framework":"nvbandwidth","measurement":"gpu_latency","unit":"ns","higher_is_better":false,"status":"ACTIVE","configs":{},"count":33,"count_servers":33,"histogram":{"breakpoints":[394.70728506178904,455.7695918929918,516.8318987241946,577.8942055553973,638.9565123866001,700.018819217803,761.0811260490057,822.1434328802086,883.2057397114113,944.268046542614,1005.3303533738169,1066.3926602050196,1127.4549670362223,1188.5172738674253,1249.579580698628,1310.6418875298307,1371.7041943610336,1432.7665011922363,1493.828808023439,1554.891114854642,1615.9534216858447],"counts":[1,0,0,1,0,0,1,6,2,1,0,3,3,5,6,0,0,0,0,4]}},{"benchmark_id":"nvbandwidth:p2p:single","name":"GPU-to-GPU P2P bandwidth (nvbandwidth)","description":"Single NVLink/P2P lane write speed (GB/s) between any two GPUs utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":33,"count_servers":33,"histogram":{"breakpoints":[9.883092939,48.124213328100005,86.3653337172,124.60645410630002,162.8475744954,201.0886948845,239.32981527360002,277.57093566270004,315.8120560518,354.0531764409,392.29429683,430.53541721910005,468.77653760820004,507.01765799730003,545.2587783864001,583.4998987755,621.7410191646001,659.9821395537001,698.2232599428,736.4643803319001,774.705500721],"counts":[8,3,0,1,0,0,8,0,0,5,5,0,0,0,0,0,0,0,0,3]}},{"benchmark_id":"nvbandwidth:slot:gpu_to_host","name":"Per-GPU GPU-to-host bandwidth (nvbandwidth)","description":"Average physical PCIe slot egress speed (GB/s) per single GPU utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[6.587282224000001,9.128712848400001,11.670143472800001,14.211574097200002,16.7530047216,19.294435346,21.8358659704,24.3772965948,26.9187272192,29.4601578436,32.001588468,34.5430190924,37.0844497168,39.6258803412,42.1673109656,44.70874159,47.2501722144,49.7916028388,52.3330334632,54.8744640876,57.415894712000004],"counts":[21,8,81,0,0,0,1,39,7,0,0,0,0,0,0,0,0,1,1,21]}},{"benchmark_id":"nvbandwidth:slot:host_to_gpu","name":"Per-GPU host-to-GPU bandwidth (nvbandwidth)","description":"Average physical PCIe slot ingest speed (GB/s) per single GPU utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[6.117650108000001,8.707140563150002,11.296631018300001,13.88612147345,16.475611928600003,19.065102383750002,21.6545928389,24.24408329405,26.8335737492,29.42306420435,32.0125546595,34.602045114650004,37.1915355698,39.78102602495,42.3705164801,44.96000693525,47.5494973904,50.13898784555,52.7284783007,55.317968755849996,57.907459210999995],"counts":[21,21,69,0,0,0,12,8,26,0,0,0,0,0,0,0,0,0,2,21]}},{"benchmark_id":"nvbandwidth:slot:latency","name":"Per-GPU host-device latency (nvbandwidth)","description":"Average round-trip transit time (ns) between CPU and individual GPUs utilizing SM (Streaming Multiprocessor).","framework":"nvbandwidth","measurement":"gpu_latency","unit":"ns","higher_is_better":false,"status":"ACTIVE","configs":{},"count":180,"count_servers":180,"histogram":{"breakpoints":[558.8017066475004,959.1866541304626,1359.5716016134247,1759.9565490963869,2160.341496579349,2560.726444062311,2961.1113915452734,3361.4963390282355,3761.8812865111977,4162.26623399416,4562.651181477122,4963.036128960084,5363.421076443046,5763.8060239260085,6164.190971408971,6564.575918891933,6964.960866374895,7365.345813857857,7765.730761340819,8166.1157088237815,8566.500656306744],"counts":[117,49,1,5,0,0,0,1,3,0,0,0,0,0,0,0,1,1,0,2]}},{"benchmark_id":"nvbandwidth:slot:local_copy","name":"Per-GPU device memory copy bandwidth (nvbandwidth)","description":"Average on-GPU memory copy bandwidth (GB/s) per single GPU (device-to-device copy within the same GPU's memory) utilizing CE (Copy Engine).","framework":"nvbandwidth","measurement":"gpu_bandwidth","unit":"GB/s","higher_is_better":true,"status":"ACTIVE","configs":{},"count":82,"count_servers":82,"histogram":{"breakpoints":[13.134034827,174.004455097075,334.87487536715,495.74529563722507,656.6157159073001,817.4861361773751,978.3565564474502,1139.226976717525,1300.0973969876002,1460.9678172576753,1621.8382375277502,1782.7086577978253,1943.5790780679004,2104.4494983379755,2265.31991860805,2426.190338878125,2587.0607591482003,2747.9311794182754,2908.8015996883505,3069.672019958425,3230.5424402285003],"counts":[34,23,5,1,7,0,0,0,0,5,0,0,2,0,0,0,0,0,0,5]}},{"benchmark_id":"openssl","name":"OpenSSL speed","description":"Measures the performance of OpenSSL's selected hash functions and block ciphers with different block sizes of data.","framework":"openssl","measurement":null,"unit":"Bytes per second (Bps)","higher_is_better":true,"status":"ACTIVE","configs":{"algo":{"description":"Hash or block cipher algorithm, e.g. sha256 or aes-256-cbc.","examples":["AES-256-CBC","ARIA-256-CBC","CAMELLIA-256-CBC","SM4-CBC","blake2b512","sha256","sha3-256","sha3-512","sha512","shake128","shake256"]},"block_size":{"description":"Block size (byte).","examples":[16,64,256,1024,8192,16384]}},"count":246444,"count_servers":3734,"histogram":{"breakpoints":[2394896.0,29798030773.5995,59593666651.199,89389302528.7985,119184938406.398,148980574283.9975,178776210161.597,208571846039.1965,238367481916.796,268163117794.39548,297958753671.995,327754389549.5945,357550025427.194,387345661304.79346,417141297182.393,446936933059.9925,476732568937.592,506528204815.19147,536323840692.79095,566119476570.3905,595915112447.99],"counts":[222575,13165,4822,2560,959,773,588,275,148,176,114,101,58,57,2,32,28,1,0,10]}},{"benchmark_id":"passmark:cpu_compression_test","name":"PassMark: CPU Compression Test","description":"Using Gzip (Crypto++ 8.6) to compress blocks of data with a 4MB memory buffer size per core.","framework":"passmark","measurement":"cpu_compression_test","unit":"Kilobytes per second (kB/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[2145.015975153107,355174.78657826077,708204.5571813683,1061234.3277844759,1414264.0983875836,1767293.8689906914,2120323.6395937987,2473353.4101969064,2826383.180800014,3179412.951403122,3532442.7220062297,3885472.492609337,4238502.263212444,4591532.0338155525,4944561.80441866,5297591.575021768,5650621.345624875,6003651.116227983,6356680.886831091,6709710.657434198,7062740.428037306],"counts":[2192,568,342,186,115,79,40,40,40,13,14,6,1,13,4,13,0,4,2,9]}},{"benchmark_id":"passmark:cpu_encryption_test","name":"PassMark: CPU Encryption Test","description":"Encrypting blocks of random data using AES, SHA256 and ECDSA with any available specialized CPU instruction sets and memory buffers totaling about 1MB per core.","framework":"passmark","measurement":"cpu_encryption_test","unit":"Megabytes per second (MB/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[73.10057925228084,21231.80725359002,42390.51392792776,63549.2206022655,84707.92727660324,105866.63395094097,127025.34062527872,148184.04729961648,169342.7539739542,190501.46064829195,211660.16732262968,232818.87399696742,253977.5806713052,275136.2873456429,296294.99401998066,317453.7006943184,338612.40736865613,359771.11404299387,380929.8207173316,402088.52739166934,423247.2340660071],"counts":[2459,458,235,156,110,76,29,54,23,22,17,9,6,1,2,9,0,1,0,14]}},{"benchmark_id":"passmark:cpu_extended_instructions_test","name":"PassMark: CPU Extended Instructions Test","description":"Testing how fast the CPU can perform mathematical operations using extended instructions, such as SSE, FMA, AVX, AVX512 and NEON.","framework":"passmark","measurement":"cpu_extended_instructions_test","unit":"Millions of matrices per second (Mmat/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[138.58969914929176,24396.947326514302,48655.30495387931,72913.66258124432,97172.02020860933,121430.37783597434,145688.73546333934,169947.09309070435,194205.45071806936,218463.80834543437,242722.16597279938,266980.5236001644,291238.88122752943,315497.2388548945,339755.59648225945,364013.95410962444,388272.3117369895,412530.6693643545,436789.0269917195,461047.3846190845,485305.7422464495],"counts":[2084,627,307,256,117,75,46,52,25,18,17,6,10,5,2,16,7,0,3,8]}},{"benchmark_id":"passmark:cpu_floating_point_maths_test","name":"PassMark: CPU Floating Point Maths Test","description":"Testing how fast the CPU can perform mathematical floating point operations, using large sets of an equal number of random 32-bit and 64-bit floating point numbers for addition (30% of the time), subtraction (30% of the time), multiplication (30% of the time) and division (10% of the time), with floating point buffers totaling about 240kb per core.","framework":"passmark","measurement":"cpu_floating_point_maths_test","unit":"Millions of operations per second (Mops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[355.05720924269735,73565.25940512428,146775.46160100584,219985.6637968874,293195.865992769,366406.0681886506,439616.27038453217,512826.47258041374,586036.6747762953,659246.876972177,732457.0791680585,805667.28136394,878877.4835598216,952087.6857557032,1025297.8879515848,1098508.0901474662,1171718.2923433478,1244928.4945392294,1318138.696735111,1391348.8989309925,1464559.101126874],"counts":[2265,547,286,196,90,37,70,68,15,32,1,4,0,13,9,24,1,6,1,16]}},{"benchmark_id":"passmark:cpu_integer_maths_test","name":"PassMark: CPU Integer Maths Test","description":"Testing how fast the CPU can perform mathematical integer operations, using large sets of an equal number of random 32-bit and 64-bit integers for addition, subtraction, multiplication and division, with integer buffers totaling about 240kb per core.","framework":"passmark","measurement":"cpu_integer_maths_test","unit":"Millions of operations per second (Mops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[567.787,100022.91021666669,199478.0334333334,298933.1566500001,398388.27986666677,497843.40308333345,597298.5263000001,696753.6495166668,796208.7727333335,895663.8959500003,995119.0191666669,1094574.1423833335,1194029.2656000003,1293484.388816667,1392939.5120333335,1492394.6352500003,1591849.758466667,1691304.8816833338,1790760.0049000005,1890215.128116667,1989670.2513333338],"counts":[2165,528,376,176,117,94,39,41,34,45,8,20,3,7,9,4,0,6,0,9]}},{"benchmark_id":"passmark:cpu_mark","name":"PassMark: CPU Mark","description":"A composite average of the Integer, Floating point, Prime and String Sorting test scores, which can be used to compare CPUs from different platforms (even e.g. desktop vs mobile).","framework":"passmark","measurement":"cpu_mark","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,9647.14709540281,19294.29419080562,28941.44128620843,38588.58838161124,48235.73547701405,57882.88257241686,67530.02966781968,77177.17676322248,86824.32385862528,96471.4709540281,106118.61804943091,115765.76514483371,125412.91224023653,135060.05933563935,144707.20643104214,154354.35352644496,164001.50062184778,173648.64771725057,183295.7948126534,192942.9419080562],"counts":[1177,589,425,324,210,223,135,130,130,77,42,53,55,33,20,22,7,3,20,6]}},{"benchmark_id":"passmark:cpu_physics_test","name":"PassMark: CPU Physics Test","description":"Simulating the same physics interactions as many times as possible within a timeframe, using the Bullet Physics Engine (version 2.88 for x86, 3.07 for ARM).","framework":"passmark","measurement":"cpu_physics_test","unit":"Frames per second (fps)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,3224.2778498142493,6448.555699628499,9672.833549442748,12897.111399256997,16121.389249071246,19345.667098885497,22569.944948699744,25794.222798513994,29018.500648328245,32242.778498142492,35467.05634795674,38691.33419777099,41915.612047585244,45139.88989739949,48364.16774721374,51588.44559702799,54812.72344684224,58037.00129665649,61261.27914647073,64485.556996284984],"counts":[2160,611,372,133,128,84,53,28,33,7,4,20,11,10,10,5,4,4,2,2]}},{"benchmark_id":"passmark:cpu_prime_numbers_test","name":"PassMark: CPU Prime Numbers Test","description":"Finding prime numbers using the Sieve of Atkin formula (with a limit of 32 million) on 64-bit integers with 4MB of memory per thread.","framework":"passmark","measurement":"cpu_prime_numbers_test","unit":"Million prime numbers per second (Mnums/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[1.0858258986299454,231.89201679520852,462.6982076917871,693.5043985883658,924.3105894849443,1155.1167803815229,1385.9229712781016,1616.7291621746801,1847.5353530712587,2078.3415439678374,2309.1477348644157,2539.9539257609945,2770.7601166575732,3001.5663075541515,3232.3724984507303,3463.1786893473086,3693.9848802438873,3924.791071140466,4155.597262037045,4386.403452933623,4617.2096438302015],"counts":[2385,584,295,124,96,39,58,36,7,14,2,5,10,13,4,1,0,2,5,1]}},{"benchmark_id":"passmark:cpu_single_threaded_test","name":"PassMark: CPU Single Threaded Test","description":"Using a single logical core for a mixture of floating point, string sorting and data compression tests.","framework":"passmark","measurement":"cpu_single_threaded_test","unit":"Millions of operations per second (Mops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[161.5500930526448,384.9862265911713,608.4223601296978,831.8584936682244,1055.2946272067509,1278.7307607452774,1502.166894283804,1725.6030278223304,1949.039161360857,2172.4752948993837,2395.91142843791,2619.3475619764367,2842.7836955149633,3066.21982905349,3289.6559625920163,3513.092096130543,3736.5282296690693,3959.964363207596,4183.400496746122,4406.836630284649,4630.272763823175],"counts":[2,5,11,9,107,174,375,471,401,513,391,176,381,268,81,139,144,4,26,3]}},{"benchmark_id":"passmark:cpu_string_sorting_test","name":"PassMark: CPU String Sorting Test","description":"Sorting strings using the Quicksort algorithm with memory buffers totaling about 25MB per core.","framework":"passmark","measurement":"cpu_string_sorting_test","unit":"Thousands of strings per second (Kstrings/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[276.86502724093737,48426.68501555786,96576.50500387479,144726.32499219172,192876.14498050863,241025.96496882554,289175.7849571425,337325.6049454594,385475.4249337763,433625.24492209323,481775.06491041015,529924.8848987271,578074.704887044,626224.5248753609,674374.3448636779,722524.1648519947,770673.9848403117,818823.8048286287,866973.6248169455,915123.4448052625,963273.2647935794],"counts":[2054,554,360,212,126,101,65,54,27,41,8,13,6,5,7,6,6,23,9,4]}},{"benchmark_id":"passmark:database_operations","name":"PassMark: Database Operations","description":"Single threaded and multi-threaded CRUD operations, such as INSERT (40%), SELECT (26%), UPDATE (24%), and DELETE (10%) on a relational database with 4 tables and 1k rows per table.","framework":"passmark","measurement":"database_operations","unit":"Thousands of operations per second (Kops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,3131.5900800164104,6263.180160032821,9394.77024004923,12526.360320065642,15657.950400082053,18789.54048009846,21921.130560114874,25052.720640131283,28184.310720147692,31315.900800164105,34447.490880180514,37579.08096019692,40710.67104021333,43842.26112022975,46973.85120024616,50105.44128026257,53237.031360278976,56368.621440295385,59500.2115203118,62631.80160032821],"counts":[1084,533,327,230,207,165,229,131,104,231,120,102,59,31,43,72,1,0,6,6]}},{"benchmark_id":"passmark:memory_latency","name":"PassMark: Memory Latency","description":"Measuring the time it takes for a single byte of memory to be transferred to the CPU for processing. A 512 MB buffer is allocated and then filled with pointers to other locations in the buffer, looping through a linked list.","framework":"passmark","measurement":"memory_latency","unit":"Nanoseconds (ns)","higher_is_better":false,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,20.266133603288583,40.53226720657717,60.798400809865754,81.06453441315433,101.33066801644291,121.59680161973151,141.8629352230201,162.12906882630867,182.39520242959725,202.66133603288583,222.9274696361744,243.19360323946302,263.45973684275157,283.7258704460402,303.9920040493287,324.25813765261734,344.52427125590594,364.7904048591945,385.0565384624831,405.32267206577166],"counts":[21,38,1525,1655,325,57,25,21,6,4,1,1,1,0,0,0,0,0,0,1]}},{"benchmark_id":"passmark:memory_mark","name":"PassMark: Memory Mark","description":"A composite score of PassMark's Database and Memory test cases","framework":"passmark","measurement":"memory_mark","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,237.11338947937602,474.22677895875205,711.3401684381281,948.4535579175041,1185.56694739688,1422.6803368762562,1659.793726355632,1896.9071158350082,2134.020505314384,2371.13389479376,2608.2472842731363,2845.3606737525124,3082.4740632318885,3319.587452711264,3556.7008421906403,3793.8142316700164,4030.9276211493925,4268.041010628768,4505.154400108145,4742.26778958752],"counts":[22,3,22,118,165,127,199,356,334,424,553,711,389,139,92,3,1,1,6,16]}},{"benchmark_id":"passmark:memory_read_cached","name":"PassMark: Memory Read Cached","description":"Read a combination of 32-bit and 64-bit data from memory.","framework":"passmark","measurement":"memory_read_cached","unit":"Megabytes per second (MB/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,2100.29021484375,4200.5804296875,6300.870644531251,8401.160859375,10501.45107421875,12601.741289062502,14702.031503906252,16802.32171875,18902.61193359375,21002.9021484375,23103.19236328125,25203.482578125004,27303.772792968753,29404.063007812503,31504.353222656253,33604.6434375,35704.93365234375,37805.2238671875,39905.51408203125,42005.804296875],"counts":[22,0,2,11,105,74,18,48,141,410,472,1003,472,474,158,96,143,7,22,3]}},{"benchmark_id":"passmark:memory_read_uncached","name":"PassMark: Memory Read Uncached","description":"Read a combination of 32-bit and 64-bit data from memory using a 512 MB block size.","framework":"passmark","measurement":"memory_read_uncached","unit":"Megabytes per second (MB/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,2013.6216796875,4027.243359375,6040.865039062501,8054.48671875,10068.1083984375,12081.730078125001,14095.351757812501,16108.9734375,18122.595117187502,20136.216796875,22149.8384765625,24163.460156250003,26177.0818359375,28190.703515625002,30204.3251953125,32217.946875,34231.5685546875,36245.190234375004,38258.8119140625,40272.43359375],"counts":[23,24,51,419,615,897,198,90,242,335,138,32,118,221,103,106,44,22,1,2]}},{"benchmark_id":"passmark:memory_write","name":"PassMark: Memory Write","description":"Write a combination of 32-bit and 64-bit data to the memory using a 512 MB block size.","framework":"passmark","measurement":"memory_write","unit":"Megabytes per second (MB/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3681,"count_servers":3681,"histogram":{"breakpoints":[0.0,1794.5869140625,3589.173828125,5383.7607421875,7178.34765625,8972.9345703125,10767.521484375,12562.1083984375,14356.6953125,16151.2822265625,17945.869140625,19740.4560546875,21535.04296875,23329.6298828125,25124.216796875,26918.8037109375,28713.390625,30507.9775390625,32302.564453125,34097.1513671875,35891.73828125],"counts":[22,22,28,293,511,909,400,117,133,144,190,251,57,68,254,27,94,97,46,18]}},{"benchmark_id":"pgbench:heavy_read_only","name":"PostgreSQL heavy read-only throughput","description":"Measures PostgreSQL throughput with a remote pgbench client against a custom, cache-resident, read-only transaction (joins, aggregates, full-text search, arrays, regex, TOAST) that fits in shared_buffers, so the score reflects engine CPU and memory behavior rather than disk or network. Server and client run in the same availability zone. Servers use pgtune-style host GUCs, while DBaaS keep the vendor-managed config. Each score is TPM at a given client concurrency; the typical profile is 1, vCPUs/2, vCPUs, and 2*vCPUs (additional points may be present). This is a synthetic proxy for relative RDBMS performance across server types, not a prediction of any specific application's throughput.","framework":"pgbench","measurement":"heavy_read_only","unit":"Transactions per minute (TPM)","higher_is_better":true,"status":"ACTIVE","configs":{"concurrency":{"description":"Parallel client query count (integer). Typical profile: 1, vCPUs/2, vCPUs, and 2*vCPUs (may include additional points).","examples":[1,2,3,4,6,7,8,10,11,12,14,15,16,18,19,20,22,24,28,30,32,36,38,40,44,45,48,52,56,60,64,72,76,80,88,90,96,104,112,120,128,144,160,176,180,192,208,224,256,288,320,360,384,448,576,720,768]}},"count":3150,"count_servers":825,"histogram":{"breakpoints":[32.0,1885.0,3738.0,5591.0,7444.0,9297.0,11150.0,13003.0,14856.0,16709.0,18562.0,20415.0,22268.0,24121.0,25974.0,27827.0,29680.0,31533.0,33386.0,35239.0,37092.0],"counts":[2061,380,266,131,108,44,46,26,28,6,20,2,0,0,16,6,1,1,0,8]}},{"benchmark_id":"pgbench:heavy_read_only:peak","name":"PostgreSQL heavy read-only peak throughput","description":"Maximum PostgreSQL throughput over the pgbench concurrency profile (typically 1, vCPUs/2, vCPUs, and 2*vCPUs) with a remote client against a custom, cache-resident, read-only transaction (joins, aggregates, full-text search, arrays, regex, TOAST) that fits in shared_buffers. Server and client run in the same availability zone. Servers use pgtune-style host GUCs, while DBaaS keep the vendor-managed config. This is a synthetic proxy for relative RDBMS performance across server types, not a prediction of any specific application's throughput.","framework":"pgbench","measurement":"heavy_read_only:peak","unit":"Transactions per minute (TPM)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":825,"count_servers":825,"histogram":{"breakpoints":[45.0,1897.35,3749.7,5602.049999999999,7454.4,9306.75,11159.099999999999,13011.449999999999,14863.8,16716.149999999998,18568.5,20420.85,22273.199999999997,24125.55,25977.899999999998,27830.25,29682.6,31534.949999999997,33387.299999999996,35239.65,37092.0],"counts":[441,128,85,49,43,10,23,7,16,1,4,1,0,0,8,4,0,1,0,4]}},{"benchmark_id":"pgbench:heavy_read_only:single","name":"PostgreSQL heavy read-only baseline (single connection)","description":"Baseline PostgreSQL throughput with a single remote pgbench client connection against a custom, cache-resident, read-only transaction (joins, aggregates, full-text search, arrays, regex, TOAST) that fits in shared_buffers. Server and client run in the same availability zone. Servers use pgtune-style host GUCs, while DBaaS keep the vendor-managed config. Useful for comparing per-session engine and CPU efficiency across server types and sizes, because the score does not necessarily scale with extra vCPUs the way peak throughput does. This is a synthetic proxy for relative RDBMS performance, not a prediction of any specific application's throughput.","framework":"pgbench","measurement":"heavy_read_only:single","unit":"Transactions per minute (TPM)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":825,"count_servers":825,"histogram":{"breakpoints":[38.0,51.05,64.1,77.15,90.2,103.25,116.30000000000001,129.35000000000002,142.4,155.45,168.5,181.55,194.60000000000002,207.65,220.70000000000002,233.75,246.8,259.85,272.9,285.95000000000005,299.0],"counts":[2,9,8,30,40,69,57,93,43,152,116,63,41,32,26,14,20,8,0,2]}},{"benchmark_id":"redis:latency","name":"Redis latency","description":"Running a pair of redis server and benchmarking client (memtier_benchmark) on each vCPU to evaluate the performance of SET operations, using different number of concurrent pipelined requests. The average latency reported by memtier_benchmark.","framework":"redis","measurement":"latency","unit":"Milliseconds (ms)","higher_is_better":false,"status":"ACTIVE","configs":{"pipeline":{"description":"The number of concurrent pipelined requests.","examples":[1.0,4.0,16.0,64.0,256.0,512.0]},"operation":{"description":"Type of operation, e.g. SET or GET a key.","examples":["SET"]}},"count":22320,"count_servers":3720,"histogram":{"breakpoints":[0.25,37.772000000000006,75.29400000000001,112.81600000000002,150.33800000000002,187.86,225.38200000000003,262.90400000000005,300.42600000000004,337.94800000000004,375.47,412.9920000000001,450.51400000000007,488.03600000000006,525.5580000000001,563.08,600.6020000000001,638.1240000000001,675.6460000000001,713.1680000000001,750.69],"counts":[18982,2751,512,56,9,2,1,2,0,0,2,0,1,0,0,0,0,1,0,1]}},{"benchmark_id":"redis:rps","name":"Redis server+client speed","description":"Running a pair of redis server and benchmarking client (memtier_benchmark) on each vCPU to evaluate the performance of SET operations, using different number of concurrent pipelined requests. The measured RPS (ops/sec) is the sum of RPS measured in all parallel processes, but is not the maximum expected redis server speed, as the server(s) share CPU with the client(s).","framework":"redis","measurement":"rps","unit":"Operations per second (ops/sec)","higher_is_better":true,"status":"ACTIVE","configs":{"pipeline":{"description":"The number of concurrent pipelined requests.","examples":[1.0,4.0,16.0,64.0,256.0,512.0]},"operation":{"description":"Type of operation, e.g. SET or GET a key.","examples":["SET"]}},"count":22320,"count_servers":3720,"histogram":{"breakpoints":[4974.0,12742393.0,25479812.0,38217231.0,50954650.0,63692069.0,76429488.0,89166907.0,101904326.0,114641745.0,127379164.0,140116583.0,152854002.0,165591421.0,178328840.0,191066259.0,203803678.0,216541097.0,229278516.0,242015935.0,254753354.0],"counts":[15939,2770,1475,765,362,286,250,93,101,28,50,49,59,20,33,21,12,4,1,2]}},{"benchmark_id":"redis:rps-extrapolated","name":"Redis server (extrapolated) speed","description":"Running a pair of redis server and benchmarking client (memtier_benchmark) on each vCPU to evaluate the performance of SET operations, using different number of concurrent pipelined requests. The extrapolated server speed is based on the measured speed adjusted by the server's and client's time spent executing in user/system mode, so trying to control for the client resource usage.","framework":"redis","measurement":"rps-extrapolated","unit":"Operations per second (ops/sec)","higher_is_better":true,"status":"ACTIVE","configs":{"pipeline":{"description":"The number of concurrent pipelined requests.","examples":[1.0,4.0,16.0,64.0,256.0,512.0]},"operation":{"description":"Type of operation, e.g. SET or GET a key.","examples":["SET"]}},"count":22320,"count_servers":3720,"histogram":{"breakpoints":[10472.92,27794598.583500005,55578724.24700001,83362849.9105,111146975.57400002,138931101.2375,166715226.901,194499352.5645,222283478.22800002,250067603.89150003,277851729.55500007,305635855.2185001,333419980.882,361204106.54550004,388988232.20900005,416772357.87250006,444556483.5360001,472340609.1995001,500124734.8630001,527908860.5265001,555692986.19],"counts":[15756,2833,1476,801,358,287,248,150,57,84,45,42,56,25,29,11,22,15,21,4]}},{"benchmark_id":"static_web:latency","name":"Static web server latency","description":"Serving smaller (1-64 KiB) and larger (256-512 KiB) files using a static HTTP server (binserve) as a single process, and benchmarking each workload (wrk) using variable number of threads (and keeping the threads with the maximum performance) and connections (recorded after divided by the number of vCPUs to make it comparable with other servers with different vCPU count) on the same server. The average latency reported by wrk.","framework":"static_web","measurement":"latency","unit":"Seconds (sec)","higher_is_better":false,"status":"ACTIVE","configs":{"size":{"description":"Served file size (KiB).","examples":["16k","1k","256k","512k","64k"]},"connections_per_vcpus":{"description":"Open HTTP connections per vCPU(s).","examples":[0.5,0.8888888888888888,1.0,1.7777777777777777,2.0,3.5555555555555554,4.0,7.111111111111111,8.0,14.222222222222221,16.0,28.444444444444443,32.0]}},"count":102340,"count_servers":3655,"histogram":{"breakpoints":[6.74e-06,0.011194402999999999,0.022382066,0.03356972899999999,0.04475739199999999,0.055945054999999994,0.067132718,0.078320381,0.089508044,0.100695707,0.11188337,0.123071033,0.13425869599999998,0.145446359,0.15663402199999998,0.167821685,0.17900934799999998,0.19019701099999997,0.20138467399999999,0.21257233699999997,0.22376],"counts":[100346,1388,209,89,60,25,34,25,31,22,20,21,15,21,13,6,8,3,2,2]}},{"benchmark_id":"static_web:rps","name":"Static web server+client speed","description":"Serving smaller (1-64 KiB) and larger (256-512 KiB) files using a static HTTP server (binserve) as a single process, and benchmarking each workload (wrk) using variable number of threads (and keeping the threads with the maximum performance) and connections (recorded after divided by the number of vCPUs to make it comparable with other servers with different vCPU count) on the same server. The measured RPS is not the maximum expected server speed, as the server shares CPU with the client.","framework":"static_web","measurement":"rps","unit":"Requests per second (rps)","higher_is_better":true,"status":"ACTIVE","configs":{"size":{"description":"Served file size (KiB).","examples":["16k","1k","256k","512k","64k"]},"connections_per_vcpus":{"description":"Open HTTP connections per vCPU(s).","examples":[0.5,0.8888888888888888,1.0,1.7777777777777777,2.0,3.5555555555555554,4.0,7.111111111111111,8.0,14.222222222222221,16.0,28.444444444444443,32.0]}},"count":102340,"count_servers":3655,"histogram":{"breakpoints":[342.0,499819.65,999297.3,1498774.9500000002,1998252.6,2497730.25,2997207.9000000004,3496685.5500000003,3996163.2,4495640.850000001,4995118.5,5494596.15,5994073.800000001,6493551.45,6993029.100000001,7492506.75,7991984.4,8491462.05,8990939.700000001,9490417.35,9989895.0],"counts":[73409,12187,5916,3871,2431,1697,1172,843,536,166,73,20,3,5,4,4,2,0,0,1]}},{"benchmark_id":"static_web:rps-extrapolated","name":"Static web server (extrapolated) speed","description":"Serving smaller (1-64 KiB) and larger (256-512 KiB) files using a static HTTP server (binserve) as a single process, and benchmarking each workload (wrk) using variable number of threads (and keeping the threads with the maximum performance) and connections (recorded after divided by the number of vCPUs to make it comparable with other servers with different vCPU count) on the same server. The extrapolated RPS is based on the measured RPS adjusted by the server's and client's time spent executing in user/system mode, so trying to control for the client resource usage.","framework":"static_web","measurement":"rps-extrapolated","unit":"Requests per second (rps)","higher_is_better":true,"status":"ACTIVE","configs":{"size":{"description":"Served file size (KiB).","examples":["16k","1k","256k","512k","64k"]},"connections_per_vcpus":{"description":"Open HTTP connections per vCPU(s).","examples":[0.5,0.8888888888888888,1.0,1.7777777777777777,2.0,3.5555555555555554,4.0,7.111111111111111,8.0,14.222222222222221,16.0,28.444444444444443,32.0]}},"count":102340,"count_servers":3655,"histogram":{"breakpoints":[603.92,1007392.266,2014180.6119999997,3020968.9579999996,4027757.3039999995,5034545.649999999,6041333.995999999,7048122.341999999,8054910.687999999,9061699.034,10068487.379999999,11075275.725999998,12082064.071999999,13088852.418,14095640.763999999,15102429.109999998,16109217.455999998,17116005.802,18122794.148000002,19129582.494,20136370.84],"counts":[74346,12367,6104,3556,2448,1629,1168,422,213,59,14,6,1,2,2,1,1,0,0,1]}},{"benchmark_id":"static_web:throughput","name":"Static web server+client throughput","description":"Serving smaller (1-64 KiB) and larger (256-512 KiB) files using a static HTTP server (binserve) as a single process, and benchmarking each workload (wrk) using variable number of threads (and keeping the threads with the maximum performance) and connections (recorded after divided by the number of vCPUs to make it comparable with other servers with different vCPU count) on the same server. Throughput is calculated by multiplying the RPS with the served file size. The measured RPS is not the maximum expected server speed, as the server shares CPU with the client.","framework":"static_web","measurement":"throughput","unit":"Bytes per second (Bps)","higher_is_better":true,"status":"ACTIVE","configs":{"size":{"description":"Served file size (KiB).","examples":["16k","1k","256k","512k","64k"]},"connections_per_vcpus":{"description":"Open HTTP connections per vCPU(s).","examples":[0.5,0.8888888888888888,1.0,1.7777777777777777,2.0,3.5555555555555554,4.0,7.111111111111111,8.0,14.222222222222221,16.0,28.444444444444443,32.0]}},"count":102340,"count_servers":3655,"histogram":{"breakpoints":[4626432.0,23794710220.8,47584794009.6,71374877798.4,95164961587.2,118955045376.0,142745129164.8,166535212953.6,190325296742.4,214115380531.19998,237905464320.0,261695548108.8,285485631897.6,309275715686.39996,333065799475.2,356855883264.0,380645967052.8,404436050841.6,428226134630.39996,452016218419.2,475806302208.0],"counts":[73500,13209,6306,3205,2075,1324,820,629,455,280,169,136,93,46,36,10,15,15,10,7]}},{"benchmark_id":"static_web:throughput-extrapolated","name":"Static web server (extrapolated) throughput","description":"Serving smaller (1-64 KiB) and larger (256-512 KiB) files using a static HTTP server (binserve) as a single process, and benchmarking each workload (wrk) using variable number of threads (and keeping the threads with the maximum performance) and connections (recorded after divided by the number of vCPUs to make it comparable with other servers with different vCPU count) on the same server. Extrapolated throughput is calculated by multiplying the extrapolated RPS with the served file size. The extrapolated RPS is based on the measured RPS adjusted by the server's and client's time spent executing in user/system mode, so trying to control for the client resource usage.","framework":"static_web","measurement":"throughput-extrapolated","unit":"Bytes per second (Bps)","higher_is_better":true,"status":"ACTIVE","configs":{"size":{"description":"Served file size (KiB).","examples":["16k","1k","256k","512k","64k"]},"connections_per_vcpus":{"description":"Open HTTP connections per vCPU(s).","examples":[0.5,0.8888888888888888,1.0,1.7777777777777777,2.0,3.5555555555555554,4.0,7.111111111111111,8.0,14.222222222222221,16.0,28.444444444444443,32.0]}},"count":102340,"count_servers":3655,"histogram":{"breakpoints":[10042490.88,50132265889.792,100254489288.70401,150376712687.61603,200498936086.528,250621159485.44,300743382884.35205,350865606283.26404,400987829682.176,451110053081.088,501232276480.0,551354499878.912,601476723277.8241,651598946676.7361,701721170075.6481,751843393474.56,801965616873.472,852087840272.384,902210063671.296,952332287070.208,1002454510469.12],"counts":[75966,13347,5427,2848,1664,1155,807,356,297,155,118,77,43,31,12,8,3,11,7,8]}},{"benchmark_id":"stress_ng:atomic","name":"stress-ng atomic","description":"Start N workers that exercise various GCC __atomic_*() built in operations on 8, 16, 32 and 64 bit integers that are shared among the N workers. This stressor is only available for builds using GCC 4.7.4 or higher. The stressor forces many front end cache stalls and cache references. Note that 32 bit systems do not currently exercise 64 bit integers. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"atomic","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4443,"count_servers":2229,"histogram":{"breakpoints":[7.76,82.3095,156.85899999999998,231.40849999999998,305.95799999999997,380.50749999999994,455.05699999999996,529.6065,604.156,678.7054999999999,753.2549999999999,827.8045,902.3539999999999,976.9034999999999,1051.453,1126.0024999999998,1200.552,1275.1015,1349.6509999999998,1424.2005,1498.7499999999998],"counts":[180,438,1253,851,395,253,281,279,106,120,75,109,54,18,12,0,7,4,2,6]}},{"benchmark_id":"stress_ng:best1","name":"stress-ng div16 single-core","description":"Stress a single vCPU core with the div16 method of stress-ng, and count the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"best1","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3737,"count_servers":3737,"histogram":{"breakpoints":[132.9,358.505,584.11,809.715,1035.3200000000002,1260.9250000000002,1486.5300000000002,1712.1350000000002,1937.7400000000002,2163.3450000000003,2388.9500000000003,2614.5550000000003,2840.1600000000003,3065.7650000000003,3291.3700000000003,3516.9750000000004,3742.5800000000004,3968.1850000000004,4193.79,4419.395,4645.0],"counts":[9,12,202,117,328,383,492,636,445,154,9,186,196,241,53,82,157,14,18,3]}},{"benchmark_id":"stress_ng:bestn","name":"stress-ng div16 multi-core","description":"Stress the CPU with the div16 method of stress-ng using a varying number of vCPU cores, and count the measured maximum total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"bestn","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{},"count":3737,"count_servers":3737,"histogram":{"breakpoints":[157.0,35824.9375,71492.875,107160.8125,142828.75,178496.6875,214164.625,249832.5625,285500.5,321168.4375,356836.375,392504.3125,428172.25,463840.1875,499508.125,535176.0625,570844.0,606511.9375,642179.875,677847.8125,713515.75],"counts":[2367,544,337,154,111,66,18,7,71,11,14,16,0,1,0,5,7,0,1,7]}},{"benchmark_id":"stress_ng:bitonicsort","name":"stress-ng bitonicsort","description":"Start N workers that sort 32 bit integers using bitonic sort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"bitonicsort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[0.8,127.37099999999998,253.94199999999998,380.513,507.08399999999995,633.6549999999999,760.2259999999999,886.7969999999998,1013.3679999999998,1139.9389999999999,1266.5099999999998,1393.0809999999997,1519.6519999999998,1646.2229999999997,1772.7939999999996,1899.3649999999998,2025.9359999999997,2152.507,2279.078,2405.649,2532.22],"counts":[3624,337,179,102,58,30,56,31,3,9,3,3,4,0,6,10,1,0,0,2]}},{"benchmark_id":"stress_ng:bitops","name":"stress-ng bitops","description":"Start N workers that perform various calculations using 32 bit integer manipulation operations. Many of these are derived from the Standford \"Bit Twiddling Hacks\" (Sean Eron Anderson) and Hacker's Delight (Henry S. Warren, Jr.). The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"bitops","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[16026.05,1964521.4725000001,3913016.895,5861512.3175,7810007.74,9758503.162500001,11706998.585,13655494.007500002,15603989.430000002,17552484.852500003,19500980.275000002,21449475.6975,23397971.12,25346466.5425,27294961.965000004,29243457.387500003,31191952.810000002,33140448.2325,35088943.655,37037439.0775,38985934.5],"counts":[3587,336,180,111,57,42,29,56,20,10,1,4,4,6,5,2,1,2,4,1]}},{"benchmark_id":"stress_ng:branch","name":"stress-ng branch","description":"Start N workers that randomly branch to 1024 randomly selected locations and hence exercise the CPU branch prediction logic. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"branch","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[19699.04,3391382.9154999997,6763066.790999999,10134750.666499998,13506434.541999998,16878118.417499997,20249802.292999998,23621486.168499995,26993170.043999996,30364853.919499997,33736537.794999994,37108221.670499995,40479905.546,43851589.4215,47223273.29699999,50594957.17249999,53966641.04799999,57338324.923499994,60710008.798999995,64081692.67449999,67453376.55],"counts":[3676,318,193,89,62,45,19,15,6,11,11,0,0,6,2,0,1,1,1,2]}},{"benchmark_id":"stress_ng:bsearch","name":"stress-ng bsearch","description":"Start N workers that binary search a sorted array of 32 bit integers using bsearch. By default, there are 65536 elements in the array. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"bsearch","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[29.99,4039.7569999999996,8049.523999999999,12059.291,16069.057999999999,20078.825,24088.592,28098.359,32108.126,36117.893,40127.659999999996,44137.426999999996,48147.193999999996,52156.960999999996,56166.727999999996,60176.494999999995,64186.261999999995,68196.029,72205.796,76215.56300000001,80225.33],"counts":[3586,328,185,113,67,39,38,31,14,17,6,2,3,6,5,9,3,2,1,3]}},{"benchmark_id":"stress_ng:bubblesort","name":"stress-ng bubblesort","description":"Start N workers that sort 32 bit integers using bubblesort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"bubblesort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4444,"count_servers":2224,"histogram":{"breakpoints":[0.2,13.63,27.060000000000002,40.49000000000001,53.92000000000001,67.35000000000001,80.78000000000002,94.21000000000001,107.64000000000001,121.07000000000002,134.5,147.93,161.36,174.79000000000002,188.22,201.65,215.08,228.51000000000002,241.94000000000003,255.37,268.8],"counts":[3685,278,185,76,64,55,22,14,25,6,3,6,6,3,2,2,3,3,0,6]}},{"benchmark_id":"stress_ng:cache","name":"stress-ng cache","description":"Start N workers that perform random wide spread memory read and writes to thrash the CPU cache. The code does not intelligently determine the CPU cache configuration and so it may be sub-optimal in producing hit-miss read/write activity for some processors. Note: to exercise cache misses it is recommended to instead use the matrix-3d stressor using the --matrix-3d-zyx option. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"cache","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4447,"count_servers":2229,"histogram":{"breakpoints":[40687.33,681841.2884999999,1322995.247,1964149.2055,2605303.164,3246457.1224999996,3887611.081,4528765.0395,5169918.998,5811072.956499999,6452226.914999999,7093380.8735,7734534.8319999995,8375688.790499999,9016842.749,9657996.7075,10299150.666,10940304.624499999,11581458.582999999,12222612.541499998,12863766.499999998],"counts":[2482,1317,316,116,58,32,17,16,18,7,4,16,7,11,8,8,4,3,4,3]}},{"benchmark_id":"stress_ng:cachehammer","name":"stress-ng cachehammer","description":"Start N workers that exercise the cache with a randomized mix of memory read/writes and where possible cache prefetches and cache flushes to random addresses in three memory mapped regions, one of which is shared among all the cache stressors and is the size of the L3 cache, one is local to each instance and is 4 times the L3 cache size and one is a single page mapping that cannot be read or written. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"cachehammer","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4447,"count_servers":2229,"histogram":{"breakpoints":[20996.89,2845146.8785,5669296.867,8493446.855500001,11317596.844,14141746.8325,16965896.821000002,19790046.8095,22614196.798,25438346.7865,28262496.775,31086646.7635,33910796.752000004,36734946.7405,39559096.729,42383246.7175,45207396.706,48031546.6945,50855696.683,53679846.6715,56503996.66],"counts":[3269,422,263,206,134,51,30,5,8,7,10,9,8,2,3,3,7,3,4,3]}},{"benchmark_id":"stress_ng:cacheline","name":"stress-ng cacheline","description":"Start N workers that exercise reading and writing individual bytes in a shared buffer that is the size of a cache line. Each stressor will run 1 or more processes to exercise bytes that are next to each other. The number of per stressor processes run will be scaled so that at least all N bytes of a N byte cache line are exercised. The intent is to try and trigger cacheline corruption, stalls and misses with shared memory accesses. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"cacheline","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4454,"count_servers":2229,"histogram":{"breakpoints":[0.52,326.9115,653.303,979.6945000000001,1306.086,1632.4775,1958.8690000000001,2285.2605,2611.652,2938.0435,3264.435,3590.8265,3917.2180000000003,4243.6095000000005,4570.001,4896.392500000001,5222.784000000001,5549.1755,5875.567000000001,6201.958500000001,6528.35],"counts":[3079,322,149,136,111,23,69,105,74,48,74,79,63,41,17,22,20,13,5,4]}},{"benchmark_id":"stress_ng:clock","name":"stress-ng clock","description":"Start N workers exercising clocks and POSIX timers. For all known clock types this will exercise clock_getres, clock_gettime and clock_nanosleep. For all known timers it will create a random duration timer and busy poll this until it expires. This stressor will cause frequent context switching. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"clock","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[2268.19,34406.6095,66545.029,98683.4485,130821.868,162960.2875,195098.707,227237.1265,259375.546,291513.9655,323652.385,355790.8045,387929.224,420067.6435,452206.063,484344.4825,516482.902,548621.3215,580759.7409999999,612898.1605,645036.58],"counts":[1829,831,344,193,219,253,196,207,132,83,41,43,29,21,18,8,5,3,0,3]}},{"benchmark_id":"stress_ng:clone","name":"stress-ng clone","description":"Start N workers that create clones (via the clone and clone3 system calls). This will rapidly try to create a default of 8192 clones that immediately die and wait in a zombie state until they are reaped. Once the maximum number of clones is reached (or clone fails because one has reached the maximum allowed) the oldest clone thread is reaped and a new clone is then created in a first-in first-out manner, and then repeated. A random clone flag is selected for each clone to try to exercise different clone operations. The clone stressor is a Linux only option. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"clone","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[14.85,1976.7375,3938.625,5900.512500000001,7862.400000000001,9824.2875,11786.175000000001,13748.0625,15709.95,17671.837499999998,19633.725,21595.6125,23557.5,25519.3875,27481.274999999998,29443.1625,31405.05,33366.9375,35328.825,37290.7125,39252.6],"counts":[3081,379,222,177,127,84,43,47,40,33,24,32,26,46,22,13,16,13,21,12]}},{"benchmark_id":"stress_ng:context","name":"stress-ng context","description":"Start N workers that run three threads that use swapcontext to implement the thread-to-thread context switching. This exercises rapid process context saving and restoring and is bandwidth limited by register and memory save and restore rates. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"context","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[403.59,97218.95449999999,194034.319,290849.6835,387665.048,484480.41250000003,581295.7769999999,678111.1414999999,774926.5059999999,871741.8705,968557.235,1065372.5995,1162187.964,1259003.3285,1355818.693,1452634.0575,1549449.422,1646264.7865,1743080.151,1839895.5155,1936710.8800000001],"counts":[3825,262,135,73,60,19,25,24,10,7,2,0,0,1,9,2,2,0,0,2]}},{"benchmark_id":"stress_ng:cpu_all","name":"stress-ng CPU all","description":"Stress the CPU with all available methods supported by stress-ng, and count the total bogo operations per second (in real time) based on wall clock run time. The stress methods include bit operations, recursive calculations, integer divisions, floating point operations, matrix multiplication, stats, trigonometric, and hash functions. Note that this is to be deprecated in favor of stress_ng:div16.","framework":"stress_ng","measurement":"cpu_all","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Stressing a single core or all cores.","examples":[1.0,2.0,3,4.0,6.0,8.0,10.0,12.0,14.0,15.0,16.0,20.0,22,24.0,26,28.0,30,32.0,36,38.0,40.0,44.0,45.0,48.0,52.0,56.0,60,64.0,72,80.0,88.0,90,96.0,104.0,112.0,120.0,128.0,144.0,160.0,176.0,180,192,208.0,224,288.0,360,384.0,416.0,448]}},"count":7362,"count_servers":3741,"histogram":{"breakpoints":[119.89924,35789.69177799999,71459.48431599999,107129.27685399998,142799.06939199998,178468.86192999996,214138.65446799996,249808.44700599997,285478.23954399995,321148.03208199993,356817.8246199999,392487.61715799995,428157.40969599993,463827.2022339999,499496.99477199995,535166.7873099999,570836.579848,606506.372386,642176.1649239999,677845.957462,713515.7499999999],"counts":[5996,542,338,152,110,66,18,17,61,10,14,17,0,1,0,5,7,0,1,7]}},{"benchmark_id":"stress_ng:cpu_sched","name":"stress-ng cpu-sched","description":"Start N workers that exercise the scheduler by moving processes to different CPUs. Each worker starts 16 child processes and repeatedly moves the processes to different CPUs and attempts changes their scheduler policy using SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_EXT, SCHED_DEADLINE, SCHED_RR and SCHED_FIFO policies. The choice of CPU placement is based on 8 different mechanisms and is changed every second to mix process placements on all the available CPUS. The child processes are run with randomizied nice settings to exercise scheduler prioritization. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"cpu_sched","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4423,"count_servers":2213,"histogram":{"breakpoints":[5.56,1129.8784999999998,2254.1969999999997,3378.5154999999995,4502.834,5627.152499999999,6751.471,7875.7895,9000.107999999998,10124.426499999998,11248.744999999997,12373.063499999998,13497.381999999998,14621.700499999997,15746.018999999998,16870.337499999998,17994.656,19118.9745,20243.292999999998,21367.6115,22491.929999999997],"counts":[3548,325,147,150,34,81,16,27,12,22,32,6,3,1,4,2,0,3,4,6]}},{"benchmark_id":"stress_ng:crypt","name":"stress-ng crypt","description":"Start N workers that encrypt a 16 character random password using crypt. The password is encrypted using bcrypt bsdicrypt descrypt gost-yescrypt MD5 NT scrypt SHA-1 SHA-256 SHA-512 SunMD5 and yescrypt encryption methods. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"crypt","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[335.66,43263.7215,86191.783,129119.84449999999,172047.906,214975.9675,257904.02899999998,300832.09049999993,343760.15199999994,386688.21349999995,429616.27499999997,472544.3364999999,515472.3979999999,558400.4595,601328.521,644256.5825,687184.644,730112.7054999999,773040.767,815968.8285,858896.89],"counts":[3621,317,172,110,48,50,35,34,17,8,18,0,0,1,2,12,2,0,7,4]}},{"benchmark_id":"stress_ng:div16","name":"stress-ng div16","description":"Stress the CPU with the div16 method of stress-ng using a varying number of vCPU cores, and count the measured maximum total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"div16","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Number of CPU cores stressed.","examples":[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0,24.0,25.0,26.0,27.0,28.0,29.0,30.0,31.0,32.0,34.0,36.0,38.0,40.0,42.0,44.0,45.0,46.0,48.0,50.0,52.0,54.0,56.0,58.0,60.0,62.0,64.0,66.0,68.0,70.0,72.0,74.0,76.0,78.0,80.0,82.0,84.0,86.0,88.0,90.0,92.0,96.0,98.0,100.0,102.0,104.0,108.0,110.0,112.0,114.0,116.0,120.0,124.0,126.0,128.0,130.0,132.0,136.0,138.0,140.0,144.0,150.0,154.0,156.0,160.0,162.0,168.0,170.0,174.0,176.0,180.0,182.0,186.0,192.0,196.0,198.0,204.0,208.0,210.0,216.0,220.0,224.0,228.0,234.0,238.0,240.0,242.0,252.0,260.0,264.0,266.0,270.0,276.0,280.0,286.0,288.0,294.0,300.0,308.0,312.0,322.0,324.0,330.0,336.0,338.0,348.0,350.0,352.0,360.0,364.0,372.0,378.0,384.0,390.0,392.0,406.0,416.0,420.0,434.0,448.0]}},"count":62298,"count_servers":3737,"histogram":{"breakpoints":[132.9,35802.0425,71471.185,107140.3275,142809.47,178478.61250000002,214147.755,249816.8975,285486.04000000004,321155.18250000005,356824.32500000007,392493.4675,428162.61000000004,463831.75250000006,499500.895,535170.0375000001,570839.18,606508.3225,642177.4650000001,677846.6075,713515.7500000001],"counts":[36241,12821,5484,2911,1792,969,477,394,560,155,102,162,27,37,28,73,26,13,15,11]}},{"benchmark_id":"stress_ng:eigen","name":"stress-ng eigen","description":"Start N workers that exercise the Eigen C++ matrix library for 2D matrix addition, multiplication, determinant, inverse and transpose operations on long double, double and float matrices. This currently is only available for gcc/g++ builds. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"eigen","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[1077.4,221327.37449999995,441577.34899999993,661827.3234999998,882077.2979999998,1102327.2724999997,1322577.2469999995,1542827.2214999995,1763077.1959999995,1983327.1704999995,2203577.1449999996,2423827.1194999996,2644077.093999999,2864327.068499999,3084577.042999999,3304827.017499999,3525076.991999999,3745326.966499999,3965576.940999999,4185826.915499999,4406076.89],"counts":[3646,355,188,90,50,33,30,24,5,8,3,1,6,2,2,8,5,0,0,2]}},{"benchmark_id":"stress_ng:eventfd","name":"stress-ng eventfd","description":"Start N parent and child worker processes that read and write 8 byte event messages between them via the eventfd mechanism (Linux only). The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"eventfd","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[3339.6,614923.6765000001,1226507.7530000003,1838091.8295000005,2449675.9060000004,3061259.9825000004,3672844.059000001,4284428.1355,4896012.212,5507596.288500001,6119180.365,6730764.441500001,7342348.518000001,7953932.594500001,8565516.671,9177100.7475,9788684.824000001,10400268.900500001,11011852.977000002,11623437.0535,12235021.13],"counts":[3283,523,271,129,92,43,32,25,9,19,4,7,7,6,2,0,1,4,0,1]}},{"benchmark_id":"stress_ng:expmath","name":"stress-ng expmath","description":"Start N workers that exercise various exponential functions with input values 0 to 1 in steps of 0.001; the results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"expmath","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[193.66,53282.14000000001,106370.62000000001,159459.1,212547.58000000002,265636.06,318724.54,371813.02,424901.5,477989.98,531078.4600000001,584166.9400000001,637255.42,690343.9,743432.3800000001,796520.8600000001,849609.3400000001,902697.8200000001,955786.3,1008874.7800000001,1061963.26],"counts":[3702,323,166,86,52,28,21,28,9,4,7,2,2,2,6,12,0,0,0,2]}},{"benchmark_id":"stress_ng:fault","name":"stress-ng fault","description":"Start N workers that generates minor and major page faults. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fault","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[855.16,24968.615500000004,49082.07100000001,73195.5265,97308.98200000002,121422.43750000003,145535.893,169649.34850000002,193762.80400000003,217876.25950000004,241989.71500000005,266103.1705,290216.626,314330.08150000003,338443.537,362556.99250000005,386670.44800000003,410783.9035,434897.35900000005,459010.81450000004,483124.2700000001],"counts":[2211,710,214,195,190,182,182,134,146,85,47,43,34,23,19,22,16,0,1,4]}},{"benchmark_id":"stress_ng:fibsearch","name":"stress-ng fibsearch","description":"Start N workers that use a search a sorted array of 32 bit integers using a Fibonacci search. A Fibonacci search is similar to a bsearch except that it uses the Fibonacci series to divide the search into unequal sized spaces. It avoids the costly division operator found in bsearches and examines closer elements on each search step so there is a slight compute and cache advantage over bsearch. By default, there are 65536 elements in the array. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fibsearch","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[35.38,4188.755999999999,8342.131999999998,12495.507999999996,16648.884,20802.26,24955.635999999995,29109.011999999995,33262.38799999999,37415.76399999999,41569.13999999999,45722.51599999999,49875.891999999985,54029.26799999999,58182.643999999986,62336.01999999999,66489.396,70642.772,74796.14799999999,78949.52399999999,83102.9],"counts":[3536,342,196,103,83,42,36,26,31,22,4,3,3,3,5,6,3,1,8,5]}},{"benchmark_id":"stress_ng:fma","name":"stress-ng fma","description":"Start N workers that exercise single and double precision floating point multiplication and add operations on arrays of 512 floating point values. More modern processors (Intel Haswell, AMD Bulldozer and Piledriver) and modern C compilers these will be performed by fused-multiply-add (fma3) opcodes. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fma","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[88859.8,17018586.5945,33948313.389,50878040.1835,67807766.978,84737493.7725,101667220.567,118596947.36150001,135526674.15600002,152456400.9505,169386127.745,186315854.53950003,203245581.33400002,220175308.1285,237105034.92300004,254034761.71750003,270964488.512,287894215.3065,304823942.101,321753668.8955,338683395.69],"counts":[3655,310,177,110,65,28,16,25,19,17,9,0,1,7,1,10,0,0,0,2]}},{"benchmark_id":"stress_ng:fork","name":"stress-ng fork","description":"Start N workers continually forking children that immediately exit. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fork","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[339.79,8455.646999999999,16571.503999999997,24687.360999999997,32803.21799999999,40919.075,49034.93199999999,57150.789,65266.64599999999,73382.50299999998,81498.35999999999,89614.21699999999,97730.07399999998,105845.93099999998,113961.78799999999,122077.64499999997,130193.50199999998,138309.359,146425.216,154541.073,162656.93],"counts":[2452,422,246,231,181,219,183,171,144,76,37,23,18,20,15,7,8,2,1,2]}},{"benchmark_id":"stress_ng:fp","name":"stress-ng fp","description":"Start N workers that exercise addition, multiplication and division operations on a range of floating point types. For each type, 8 floating point values are operated upon 65536 times in a loop per bogo op. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fp","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[26.4,3350.4340000000007,6674.468000000001,9998.502000000002,13322.536000000002,16646.570000000003,19970.604000000007,23294.638000000006,26618.672000000006,29942.706000000006,33266.740000000005,36590.774000000005,39914.80800000001,43238.84200000001,46562.87600000001,49886.91000000001,53210.94400000001,56534.97800000001,59859.01200000001,63183.04600000001,66507.08],"counts":[3680,310,155,100,63,24,23,22,11,20,19,6,2,0,9,0,0,1,3,4]}},{"benchmark_id":"stress_ng:fractal","name":"stress-ng fractal","description":"Start N workers that generate 2D fractals. By default a 1024 x 1024 point Mandelbrot set is computed with a maximum of 256 iterations per point in the iterative compute loop. The fractal is computed row by row with multiple rows shared amongst the N fractal stressor instances. Double precision floating point values are used for the points in the complex set of values. Naive computation is used with no special algorithmic shortcuts or interpolation. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"fractal","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[0.8,101.7555,202.711,303.6665,404.622,505.57750000000004,606.5329999999999,707.4884999999999,808.444,909.3995,1010.355,1111.3105,1212.2659999999998,1313.2214999999999,1414.177,1515.1325,1616.088,1717.0435,1817.999,1918.9545,2019.91],"counts":[3579,330,172,119,72,36,26,42,23,12,5,1,1,10,11,0,6,0,1,6]}},{"benchmark_id":"stress_ng:funccall","name":"stress-ng funccall","description":"Start N workers that call functions of 1 through to 9 arguments. By default all functions with a range of argument types are called, however, this can be changed using the --funccall-method option. This exercises stack function argument passing and re-ordering on the stack and in registers. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"funccall","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[61.06,21826.581000000002,43592.102,65357.623,87123.144,108888.66500000001,130654.186,152419.707,174185.228,195950.749,217716.27000000002,239481.791,261247.312,283012.833,304778.354,326543.875,348309.396,370074.917,391840.438,413605.95900000003,435371.48000000004],"counts":[3988,241,80,63,26,14,13,9,9,2,3,2,0,0,0,0,2,0,0,6]}},{"benchmark_id":"stress_ng:funcret","name":"stress-ng funcret","description":"Start N workers that pass and return by value various small to large data types. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"funcret","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[1953.03,363235.58050000004,724518.131,1085800.6815000002,1447083.232,1808365.7825,2169648.333,2530930.8835,2892213.434,3253495.9845,3614778.5349999997,3976061.0855,4337343.636000001,4698626.186500001,5059908.737000001,5421191.287500001,5782473.838,6143756.3885,6505038.939,6866321.4895,7227604.04],"counts":[3774,295,149,73,61,37,20,4,20,2,4,5,5,3,0,0,0,0,0,6]}},{"benchmark_id":"stress_ng:getrandom","name":"stress-ng getrandom","description":"Start N workers that get 8192 random bytes from the /dev/urandom pool using the getrandom system call (Linux) or getentropy (OpenBSD). The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"getrandom","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[5179.37,878014.645,1750849.9200000002,2623685.1950000003,3496520.47,4369355.745,5242191.0200000005,6115026.295,6987861.57,7860696.845000001,8733532.12,9606367.395,10479202.67,11352037.945,12224873.219999999,13097708.495,13970543.77,14843379.045,15716214.32,16589049.594999999,17461884.87],"counts":[3641,324,170,108,60,38,32,21,15,7,8,4,5,4,1,9,6,2,1,2]}},{"benchmark_id":"stress_ng:hash","name":"stress-ng hash","description":"Start N workers that exercise various hashing functions. Random strings from 1 to 128 bytes are hashed and the hashing rate and chi squared is calculated from the number of hashes performed over a period of time. The chi squared value is the goodness-of-fit measure, it is the actual distribution of items in hash buckets versus the expected distribution of items. Typically a chi squared value close to 1.0 indicates a good hash distribution. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"hash","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[15395.57,2683311.6059999997,5351227.642,8019143.677999999,10687059.714,13354975.75,16022891.785999998,18690807.822,21358723.858,24026639.893999998,26694555.93,29362471.966,32030388.001999997,34698304.037999995,37366220.074,40034136.11,42702052.146,45369968.182,48037884.217999995,50705800.254,53373716.29],"counts":[3638,319,180,110,47,35,37,26,20,7,6,1,11,4,3,12,0,0,0,2]}},{"benchmark_id":"stress_ng:heapsort","name":"stress-ng heapsort","description":"Start N workers that sort 32 bit integers using the BSD heapsort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"heapsort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[1.0,146.7665,292.533,438.2995,584.066,729.8325,875.599,1021.3655000000001,1167.132,1312.8985,1458.665,1604.4315000000001,1750.198,1895.9645,2041.7310000000002,2187.4975,2333.264,2479.0305000000003,2624.797,2770.5635,2916.33],"counts":[3599,337,172,116,58,32,47,31,15,10,4,0,1,10,10,4,4,0,1,7]}},{"benchmark_id":"stress_ng:hrtimers","name":"stress-ng hrtimers","description":"Start N workers that exercise high resolution times at a high frequency. Each stressor starts 32 processes that run with random timer intervals of 0..499999 nanoseconds. Running this stressor with appropriate privilege will run these with the SCHED_RR policy. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"hrtimers","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[8746.41,1353467.8945,2698189.379,4042910.8635,5387632.348,6732353.8325000005,8077075.317,9421796.8015,10766518.286,12111239.7705,13455961.255,14800682.739500001,16145404.224,17490125.7085,18834847.193,20179568.677500002,21524290.162,22869011.6465,24213733.131,25558454.6155,26903176.1],"counts":[3284,481,203,127,111,75,54,41,22,13,11,10,7,6,2,0,2,3,0,1]}},{"benchmark_id":"stress_ng:hsearch","name":"stress-ng hsearch","description":"Start N workers that search a 80% full hash table using hsearch. By default, there are 8192 elements inserted into the hash table. This is a useful method to exercise access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"hsearch","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[843.36,104474.50099999999,208105.64199999996,311736.78299999994,415367.92399999994,518999.06499999994,622630.2059999999,726261.347,829892.4879999999,933523.6289999998,1037154.7699999999,1140785.911,1244417.052,1348048.193,1451679.334,1555310.4749999999,1658941.616,1762572.757,1866203.8979999998,1969835.0389999999,2073466.18],"counts":[3603,300,170,117,70,39,35,44,29,8,8,6,1,0,4,10,4,1,1,8]}},{"benchmark_id":"stress_ng:hyperbolic","name":"stress-ng hyperbolic","description":"Start N workers that exercise sinh, cosh, and tanh libm hyperbolic functions using float, double and long double floating point variants. Each function is exercised 10000 times per bogo-operation. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"hyperbolic","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[191.72,61633.4925,123075.265,184517.0375,245958.81,307400.58249999996,368842.355,430284.12749999994,491725.89999999997,553167.6725,614609.445,676051.2174999999,737492.99,798934.7625,860376.5349999999,921818.3075,983260.08,1044701.8524999999,1106143.625,1167585.3975,1229027.17],"counts":[3692,322,153,103,37,34,23,36,13,7,5,0,1,7,4,11,2,0,0,2]}},{"benchmark_id":"stress_ng:insertionsort","name":"stress-ng insertionsort","description":"Start N workers that sort 32 bit integers using insertion sort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"insertionsort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[1.0,135.3695,269.739,404.10849999999994,538.478,672.8475,807.2169999999999,941.5864999999999,1075.956,1210.3255,1344.695,1479.0645,1613.4339999999997,1747.8034999999998,1882.1729999999998,2016.5424999999998,2150.912,2285.2814999999996,2419.651,2554.0204999999996,2688.39],"counts":[3665,314,181,103,51,29,45,23,0,14,5,11,1,0,7,7,0,0,0,2]}},{"benchmark_id":"stress_ng:intmath","name":"stress-ng intmath","description":"Start N workers that perform addition, subtraction, multiplication, division and modulo math operations on 128, 64, 32, 16 and 8 bit signed integers. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"intmath","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[6479.09,842998.914,1679518.7380000001,2516038.562,3352558.386,4189078.21,5025598.034,5862117.858,6698637.682,7535157.506,8371677.33,9208197.154,10044716.978,10881236.802000001,11717756.626,12554276.45,13390796.274,14227316.098000001,15063835.922,15900355.746,16736875.57],"counts":[3663,297,171,97,56,41,18,43,25,13,7,1,0,1,9,0,4,1,1,4]}},{"benchmark_id":"stress_ng:ipsec_mb","name":"stress-ng ipsec-mb","description":"Start N workers that perform cryptographic processing using the highly optimized Intel Multi-Buffer Crypto for IPsec library. Depending on the features available, SSE, AVX, AVX and AVX512 CPU features will be used on data encrypted by SHA, DES, CMAC, CTR, HMAC MD5, HMAC SHA1 and HMAC SHA512 cryptographic routines. This is only available for x86-64 modern Intel CPUs. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"ipsec_mb","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":[]}},"count":0,"count_servers":0,"histogram":null},{"benchmark_id":"stress_ng:jpeg","name":"stress-ng jpeg","description":"Start N workers that use jpeg compression on a machine generated plasma field image. The default image is a plasma field, however different image types may be selected. The starting raster line is changed on each compression iteration to cycle around the data. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"jpeg","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[82.6,9712.724,19342.847999999998,28972.971999999998,38603.096,48233.219999999994,57863.344,67493.46800000001,77123.592,86753.716,96383.84,106013.964,115644.088,125274.212,134904.336,144534.46,154164.584,163794.708,173424.832,183054.956,192685.08],"counts":[3545,308,205,122,90,53,25,39,20,12,11,10,3,1,0,1,8,3,0,2]}},{"benchmark_id":"stress_ng:l1cache","name":"stress-ng l1cache","description":"Start N workers that exercise the CPU level 1 cache with reads and writes. A cache aligned buffer that is twice the level 1 cache size is read and then written in level 1 cache set sized steps over each level 1 cache set. This is designed to exercise cache block evictions. The bogo-op count measures the number of million cache lines touched. Where possible, the level 1 cache geometry is determined from the kernel, however, this is not possible on some architectures or kernels, so one may need to specify these manually. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"l1cache","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4423,"count_servers":2213,"histogram":{"breakpoints":[17.72,9790.095,19562.47,29334.845,39107.22,48879.595,58651.97,68424.345,78196.72,87969.095,97741.47,107513.845,117286.22,127058.595,136830.97,146603.345,156375.72,166148.095,175920.47,185692.845,195465.22],"counts":[3985,226,135,24,15,13,6,8,6,0,2,0,0,0,0,1,1,0,0,1]}},{"benchmark_id":"stress_ng:logmath","name":"stress-ng logmath","description":"Start N workers that exercise various libm logarithmic functions with input values 1 to 10000. Results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"logmath","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[237.47,86205.37650000001,172173.28300000002,258141.18950000004,344109.096,430077.00250000006,516044.90900000004,602012.8155,687980.7220000001,773948.6285000001,859916.5350000001,945884.4415000001,1031852.3480000001,1117820.2545,1203788.161,1289756.0675000001,1375723.9740000002,1461691.8805000002,1547659.7870000002,1633627.6935000003,1719595.6000000003],"counts":[3706,337,153,93,48,25,18,27,8,6,7,2,3,3,5,9,0,0,0,2]}},{"benchmark_id":"stress_ng:malloc","name":"stress-ng malloc","description":"Start N workers continuously calling malloc, calloc, realloc, posix_memalign, aligned_alloc, memalign and free. By default, up to 65536 allocations can be active at any point, but this can be altered with the --malloc-max option. Allocation, reallocation and freeing are chosen at random; 50% of the time memory is allocation (via one of malloc, calloc or realloc, posix_memalign, aligned_alloc, memalign) and 50% of the time allocations are free'd. Allocation sizes are also random, with the maximum allocation size controlled by the --malloc-bytes option. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"malloc","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2227,"histogram":{"breakpoints":[18009.31,19461557.858499996,38905106.407,58348654.95549999,77792203.504,97235752.0525,116679300.60099998,136122849.14949998,155566397.69799998,175009946.2465,194453494.795,213897043.3435,233340591.89199996,252784140.44049996,272227688.98899996,291671237.53749996,311114786.08599997,330558334.63449997,350001883.18299997,369445431.73149997,388888980.28],"counts":[3195,523,251,145,95,80,69,21,15,12,11,8,10,5,1,5,2,0,2,2]}},{"benchmark_id":"stress_ng:matrix","name":"stress-ng matrix","description":"Start N workers that perform various matrix operations on floating point values. Testing on 64 bit x86 hardware shows that this provides a good mix of memory, cache and floating point operations and is an excellent way to make a CPU run hot. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"matrix","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[315.85,76364.87849999999,152413.90699999998,228462.93549999996,304511.9639999999,380560.99249999993,456610.0209999999,532659.0494999998,608708.0779999999,684757.1064999999,760806.1349999999,836855.1634999998,912904.1919999998,988953.2204999998,1065002.2489999998,1141051.2774999999,1217100.3059999999,1293149.3344999999,1369198.363,1445247.3915,1521296.42],"counts":[3654,320,175,99,53,45,39,13,14,1,2,15,7,2,0,5,1,1,0,6]}},{"benchmark_id":"stress_ng:matrix_3d","name":"stress-ng matrix-3d","description":"Start N workers that perform various 3D matrix operations on floating point values. Testing on 64 bit x86 hardware shows that this provides a good mix of memory, cache and floating point operations and is an excellent way to make a CPU run hot. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"matrix_3d","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[48.08,2552.5094999999997,5056.938999999999,7561.368499999999,10065.797999999999,12570.227499999999,15074.656999999997,17579.0865,20083.516,22587.945499999998,25092.375,27596.8045,30101.233999999997,32605.6635,35110.093,37614.5225,40118.952,42623.381499999996,45127.810999999994,47632.2405,50136.67],"counts":[3219,526,286,111,78,72,45,34,24,14,17,1,0,5,6,0,5,5,2,2]}},{"benchmark_id":"stress_ng:mcontend","name":"stress-ng mcontend","description":"Start N workers that produce memory contention read/write patterns. Each stressor runs with 5 threads that read and write to two different mappings of the same underlying physical page. Various caching operations are also exercised to cause sub-optimal memory access patterns. The threads also randomly change CPU affinity to exercise CPU and memory migration stress. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"mcontend","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[0.1,25089.934,50179.768000000004,75269.60200000001,100359.43600000002,125449.27000000002,150539.10400000002,175628.93800000002,200718.77200000003,225808.60600000003,250898.44000000003,275988.274,301078.108,326167.94200000004,351257.776,376347.61,401437.444,426527.27800000005,451617.112,476706.946,501796.78],"counts":[4300,73,15,15,15,11,7,4,0,8,0,0,0,0,0,4,0,0,0,6]}},{"benchmark_id":"stress_ng:memcpy","name":"stress-ng memcpy","description":"Start N workers that copies data to and from a buffer using memcpy and then move the data in the buffer with memmove with 3 different alignments. This will exercise the data cache and memory copying. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"memcpy","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[37.15,8771.229000000001,17505.308000000005,26239.387000000006,34973.46600000001,43707.545000000006,52441.62400000001,61175.703000000016,69909.782,78643.861,87377.94,96112.01900000001,104846.09800000001,113580.17700000001,122314.25600000002,131048.33500000002,139782.41400000002,148516.49300000002,157250.57200000001,165984.651,174718.73],"counts":[3798,303,134,75,46,31,10,19,14,0,5,1,9,3,1,1,2,0,0,6]}},{"benchmark_id":"stress_ng:memrate","name":"stress-ng memrate","description":"Start N workers that exercise a buffer with 1024, 512, 256, 128, 64, 32, 16 and 8 bit reads and writes. 1024, 512 and 256 reads and writes are available with compilers that support integer vectors. x86-64 cpus that support uncached (non-temporal \"nt\") writes also exercise 128, 64 and 32 writes providing higher write rates than the normal cached writes. x86-64 also exercises repeated string stores using 64, 32, 16 and 8 bit writes. CPUs that support prefetching reads also exercise 64 prefetched \"pf\" reads. This memory stressor allows one to also specify the maximum read and write rates. The stressors will run at maximum speed if no read or write rates are specified. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"memrate","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4371,"count_servers":2189,"histogram":{"breakpoints":[0.1,6.87,13.64,20.410000000000004,27.180000000000003,33.95,40.720000000000006,47.49,54.260000000000005,61.03000000000001,67.8,74.57,81.34,88.11,94.88,101.65,108.42,115.19,121.96000000000001,128.73,135.5],"counts":[3260,553,216,112,67,59,26,21,13,18,16,0,0,1,6,0,0,0,1,2]}},{"benchmark_id":"stress_ng:memthrash","name":"stress-ng memthrash","description":"Start N workers that thrash and exercise a 16 MB buffer in various ways to try and trip thermal overrun. Each stressor will start 1 or more threads. The number of threads is chosen so that there will be at least 1 thread per CPU. Note that the optimal choice for N is a value that divides into the number of CPUs. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"memthrash","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4439,"count_servers":2225,"histogram":{"breakpoints":[7.66,178.9175,350.175,521.4325,692.6899999999999,863.9474999999999,1035.2050000000002,1206.4625,1377.72,1548.9775,1720.235,1891.4925,2062.75,2234.0074999999997,2405.265,2576.5224999999996,2747.7799999999997,2919.0375,3090.2949999999996,3261.5525,3432.8099999999995],"counts":[2023,1102,343,217,182,130,100,77,59,43,53,37,30,21,10,3,1,6,1,1]}},{"benchmark_id":"stress_ng:mergesort","name":"stress-ng mergesort","description":"Start N workers that sort 32 bit integers using the BSD mergesort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"mergesort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[3.51,438.02549999999997,872.5409999999999,1307.0565,1741.572,2176.0875,2610.603,3045.1185,3479.634,3914.1495,4348.665,4783.1805,5217.696,5652.211499999999,6086.727,6521.2425,6955.758,7390.273499999999,7824.789,8259.3045,8693.82],"counts":[3564,341,197,107,72,43,23,35,28,4,9,3,6,2,2,6,9,4,1,2]}},{"benchmark_id":"stress_ng:monte_carlo","name":"stress-ng monte-carlo","description":"Start N stressors that compute <pi> and e (Euler's number) using Monte Carlo computational experiments with various random number generators. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"monte_carlo","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[29.53,5097.0255,10164.521,15232.0165,20299.512,25367.0075,30434.502999999997,35501.9985,40569.494,45636.989499999996,50704.485,55771.9805,60839.475999999995,65906.9715,70974.467,76041.9625,81109.458,86176.9535,91244.449,96311.9445,101379.44],"counts":[3799,270,138,96,45,28,19,23,7,8,9,1,0,1,6,6,0,0,1,1]}},{"benchmark_id":"stress_ng:mpfr","name":"stress-ng mpfr","description":"Start N workers that exercise multi-precision floating point operations using the GNU Multi-Precision Floating Point Reliable library (mpfr). The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"mpfr","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[156.77,21080.628,42004.486,62928.344,83852.202,104776.06000000001,125699.918,146623.77599999998,167547.634,188471.492,209395.35,230319.20799999998,251243.066,272166.924,293090.782,314014.64,334938.498,355862.356,376786.21400000004,397710.07200000004,418633.93000000005],"counts":[3602,333,168,109,65,28,51,38,11,7,8,7,5,0,0,9,11,4,0,2]}},{"benchmark_id":"stress_ng:mprotect","name":"stress-ng mprotect","description":"Start N workers that exercise changing page protection settings and access memory after each change. 8 processes per worker contend with each other changing page protection settings on a shared memory region of just a few pages to cause TLB flushes. A read and write to the pages can cause segmentation faults and these are handled by the stressor. All combinations of page protection settings are exercised including invalid combinations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"mprotect","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[39383.83,1934376.6015,3829369.373,5724362.1445,7619354.916,9514347.6875,11409340.459,13304333.2305,15199326.002,17094318.7735,18989311.544999998,20884304.316499997,22779297.088,24674289.8595,26569282.630999997,28464275.4025,30359268.174,32254260.945499998,34149253.717,36044246.4885,37939239.26],"counts":[3132,337,212,141,124,89,89,95,76,55,41,22,17,12,3,7,1,1,2,2]}},{"benchmark_id":"stress_ng:mtx","name":"stress-ng mtx","description":"Start N stressors that exercise ISO C mutex locking and unlocking. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"mtx","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[2142459.71,814067253.2770001,1625992046.844,2437916840.4110003,3249841633.978,4061766427.545,4873691221.112,5685616014.679,6497540808.246,7309465601.813001,8121390395.38,8933315188.946999,9745239982.514,10557164776.081,11369089569.647999,12181014363.215,12992939156.782,13804863950.348999,14616788743.916,15428713537.483,16240638331.05],"counts":[3569,346,176,109,75,72,20,26,13,13,4,6,11,3,2,6,1,0,0,1]}},{"benchmark_id":"stress_ng:munmap","name":"stress-ng munmap","description":"Start N stressors that exercise unmapping of shared non-executable mapped regions of child processes (Linux only). The unmappings map shared memory regions page by page with a prime sized stride that creates many temporary mapping holes. One the unmappings are complete the child will exit and a new one is started. Note that this may trigger segmentation faults in the child process, these are handled where possible by forcing the child process to call _exit. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"munmap","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[244.39,7949.1765,15653.962999999998,23358.749499999998,31063.535999999996,38768.322499999995,46473.109,54177.89549999999,61882.68199999999,69587.46849999999,77292.25499999999,84997.04149999999,92701.828,100406.6145,108111.40099999998,115816.18749999999,123520.97399999999,131225.7605,138930.547,146635.3335,154340.12],"counts":[2611,407,248,188,192,139,177,123,134,72,45,28,14,29,17,12,10,2,2,3]}},{"benchmark_id":"stress_ng:nop","name":"stress-ng nop","description":"Start N workers that consume cpu cycles issuing no-op instructions. This stressor is available if the assembler supports the \"nop\" instruction. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"nop","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[33036.12,5753851.404999999,11474666.689999998,17195481.974999998,22916297.259999998,28637112.544999998,34357927.82999999,40078743.114999995,45799558.39999999,51520373.68499999,57241188.96999999,62962004.25499999,68682819.53999999,74403634.82499999,80124450.11,85845265.395,91566080.67999999,97286895.96499999,103007711.24999999,108728526.535,114449341.82],"counts":[3858,251,112,81,41,40,14,24,1,5,13,1,1,3,8,0,0,1,0,4]}},{"benchmark_id":"stress_ng:null","name":"stress-ng null","description":"Start N workers that exercise /dev/null with write, lseek, ioctl, fcntl, fallocate and fdatasync calls. For just /dev/null write benchmarking use the --null-write option. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"null","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[42519.68,15991843.021,31941166.362,47890489.703,63839813.044,79789136.385,95738459.72600001,111687783.067,127637106.408,143586429.749,159535753.09,175485076.431,191434399.772,207383723.113,223333046.454,239282369.79500002,255231693.136,271181016.477,287130339.818,303079663.159,319028986.5],"counts":[3895,252,113,74,34,16,20,14,19,4,1,1,1,0,5,1,6,0,1,1]}},{"benchmark_id":"stress_ng:pipe","name":"stress-ng pipe","description":"Start N workers that perform large pipe writes and reads to exercise pipe I/O. This exercises memory write and reads as well as context switching. Each worker has two processes, a reader and a writer. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"pipe","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[67483.33,13374721.627999999,26681959.925999995,39989198.22399999,53296436.52199999,66603674.81999999,79910913.11799999,93218151.416,106525389.71399999,119832628.01199998,133139866.30999999,146447104.608,159754342.906,173061581.204,186368819.502,199676057.79999998,212983296.098,226290534.396,239597772.69399998,252905010.99199998,266212249.29],"counts":[3768,324,145,71,46,21,24,12,16,6,8,0,2,3,4,1,1,0,0,1]}},{"benchmark_id":"stress_ng:powmath","name":"stress-ng powmath","description":"Start N workers that exercise various libm power functions with input values 0 to 1 in steps of 0.001; the results are sanity checked to ensure no variation occurs after each round of 10000 computations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"powmath","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[137.76,31262.619499999997,62387.479,93512.3385,124637.19799999999,155762.0575,186886.91700000002,218011.7765,249136.636,280261.4955,311386.355,342511.2145,373636.074,404760.9335,435885.793,467010.65249999997,498135.512,529260.3715,560385.231,591510.0904999999,622634.95],"counts":[3745,326,150,80,43,19,23,25,5,7,8,3,1,0,6,9,0,0,0,2]}},{"benchmark_id":"stress_ng:prime","name":"stress-ng prime","description":"Start N workers that find prime numbers using the GNU Multiple Precision Arithmetic Library for large integers. The GMP mpz_nextprime function is used to find primes and it uses a probabilistic algorithm to identify primes, but there is a extremely small chance that the values found are non-prime. The search becomes computationally more expensive over time to find larger and larger primes, hence the bogo-op rate will reduce over time. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"prime","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[52758.22,6082339.297499999,12111920.375,18141501.452499997,24171082.529999997,30200663.607499998,36230244.684999995,42259825.762499996,48289406.839999996,54318987.9175,60348568.995,66378150.0725,72407731.14999999,78437312.22749999,84466893.30499999,90496474.3825,96526055.46,102555636.5375,108585217.615,114614798.6925,120644379.77],"counts":[3603,329,178,99,65,42,30,47,13,5,11,7,1,0,4,12,4,0,4,4]}},{"benchmark_id":"stress_ng:priv_instr","name":"stress-ng priv-instr","description":"Start N workers that exercise various architecture specific privileged instructions that cannot be executed by userspace programs. These instructions will be trapped and processed by SIGSEGV or SIGILL signal handlers. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"priv_instr","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[44608.26,1707228.1925,3369848.1249999995,5032468.057499999,6695087.989999999,8357707.922499999,10020327.854999999,11682947.7875,13345567.719999999,15008187.652499998,16670807.584999999,18333427.517500002,19996047.45,21658667.3825,23321287.315,24983907.2475,26646527.18,28309147.1125,29971767.044999998,31634386.9775,33297006.91],"counts":[2781,353,228,151,178,162,121,70,134,88,64,33,33,9,8,13,4,2,15,11]}},{"benchmark_id":"stress_ng:ptr_chase","name":"stress-ng ptr-chase","description":"Start N workers that chase memory pointers around page sized nodes of pointers. By default each stressor instance allocates 4096 pages of nodes, each node is an array of pointers that are randomly set to point to other node pages. The stressors follow randomly chosen pointers from each node, chasing around the entire node space. This exercises pointer fetching, pointer dereferencing and is a cache-read exercising stressor. The nodes are allocated with 50% of pages from the heap and 50% from mmap'd memory. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"ptr_chase","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[835027.31,172967067.4395,345099107.569,517231147.6985,689363187.828,861495227.9575,1033627268.0869999,1205759308.2165,1377891348.346,1550023388.4754999,1722155428.605,1894287468.7345,2066419508.8639998,2238551548.9934998,2410683589.123,2582815629.2525,2754947669.382,2927079709.5115,3099211749.641,3271343789.7705,3443475829.9],"counts":[3481,389,224,122,87,47,20,28,16,13,7,1,10,2,5,3,1,1,0,1]}},{"benchmark_id":"stress_ng:qsort","name":"stress-ng qsort","description":"Start N workers that sort 32 bit integers using qsort. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"qsort","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[2.2,302.4625,602.725,902.9875,1203.25,1503.5125,1803.7749999999999,2104.0375,2404.2999999999997,2704.5624999999995,3004.825,3305.0874999999996,3605.3499999999995,3905.6124999999997,4205.875,4506.1375,4806.4,5106.662499999999,5406.924999999999,5707.1875,6007.45],"counts":[3597,329,194,101,65,45,21,42,17,2,15,1,3,4,1,9,8,2,0,2]}},{"benchmark_id":"stress_ng:resched","name":"stress-ng resched","description":"Start N workers that exercise process rescheduling. Each stressor spawns a child process for each of the positive nice levels and iterates over the nice levels from 0 to the lowest priority level (highest nice value). For each of the nice levels 1024 iterations over 3 non-real time scheduling polices SCHED_OTHER, SCHED_BATCH and SCHED_IDLE are set and a sched_yield occurs to force heavy rescheduling activity. When the -v verbose option is used the distribution of the number of yields across the nice levels is printed for the first stressor out of the N stressors. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"resched","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[13755.36,5363326.797,10712898.234,16062469.671,21412041.108,26761612.544999998,32111183.982,37460755.419,42810326.856,48159898.293,53509469.73,58859041.166999996,64208612.604,69558184.041,74907755.478,80257326.91499999,85606898.352,90956469.789,96306041.226,101655612.663,107005184.1],"counts":[3292,711,301,73,44,19,5,0,1,1,0,2,1,0,0,0,1,0,1,1]}},{"benchmark_id":"stress_ng:rotate","name":"stress-ng rotate","description":"Start N workers that exercise 1 bit rotates left and right of unsigned integer variables. The default will rotate four 8, 16, 32, 64 (and if supported 128) bit values 10000 times in a loop per bogo-op. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"rotate","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[8991.92,1773686.5825,3538381.245,5303075.907500001,7067770.57,8832465.2325,10597159.895000001,12361854.557500001,14126549.22,15891243.8825,17655938.545,19420633.207500003,21185327.870000005,22950022.532500003,24714717.195000004,26479411.8575,28244106.520000003,30008801.182500005,31773495.845000003,33538190.507500004,35302885.17],"counts":[3727,339,142,71,72,32,4,22,8,7,5,1,0,4,8,11,3,0,0,2]}},{"benchmark_id":"stress_ng:skiplist","name":"stress-ng skiplist","description":"Start N workers that store and then search for integers using a skiplist. By default, 65536 integers are added and searched. This is a useful method to exercise random access of memory and processor cache. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"skiplist","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[704.58,102705.104,204705.628,306706.15200000006,408706.67600000004,510707.2,612707.724,714708.248,816708.772,918709.296,1020709.82,1122710.344,1224710.8680000002,1326711.3920000002,1428711.9160000002,1530712.4400000002,1632712.9640000002,1734713.4880000001,1836714.012,1938714.536,2040715.06],"counts":[3618,321,180,111,68,29,44,28,9,10,6,2,7,4,5,10,1,1,2,2]}},{"benchmark_id":"stress_ng:spinmem","name":"stress-ng spinmem","description":"Start N workers that use a shared memory page to keep two processes synchronized using busy spin loops. One process is a writer that increments a value in memory slot 0 and spin waits for the data to appear in memory slot 1. The other process spin waits for the data to change in slot 0 and copies the changed value into memory slot 1. The stressor benchmarks the time for the transactions to occur between both processes. Note that the optimal number of stressors is half the number of online CPUs in a system. By default 32 bit write/reads are used. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"spinmem","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4428,"count_servers":2225,"histogram":{"breakpoints":[0.2,9040.52,18080.84,27121.16,36161.479999999996,45201.799999999996,54242.119999999995,63282.439999999995,72322.76,81363.08,90403.4,99443.71999999999,108484.04,117524.36,126564.68,135605.0,144645.32,153685.64,162725.96000000002,171766.28,180806.6],"counts":[4302,46,20,12,5,6,9,5,1,1,6,4,2,1,1,0,1,0,1,5]}},{"benchmark_id":"stress_ng:str","name":"stress-ng str","description":"Start N workers that exercise various libc string functions on random strings. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"str","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[91607.96,12999450.188000001,25907292.416,38815134.644,51722976.872,64630819.1,77538661.328,90446503.556,103354345.784,116262188.012,129170030.24,142077872.46800002,154985714.696,167893556.924,180801399.152,193709241.38000003,206617083.608,219524925.836,232432768.064,245340610.29200003,258248452.52],"counts":[3586,344,180,106,72,36,32,42,14,3,12,5,0,6,3,12,2,1,1,1]}},{"benchmark_id":"stress_ng:stream","name":"stress-ng stream","description":"Start N workers exercising a memory bandwidth stressor very loosely based on the STREAM \"Sustainable Memory Bandwidth in High Performance Computers\" benchmarking tool by John D. McCalpin, Ph.D. This stressor allocates 3 buffers that are at the size of the CPU L3 cache and continually performs rounds of computations on large arrays of double precision floating point numbers. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"stream","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4451,"count_servers":2226,"histogram":{"breakpoints":[0.17,502057.423,1004114.6760000001,1506171.929,2008229.182,2510286.435,3012343.688,3514400.941,4016458.194,4518515.447000001,5020572.7,5522629.953,6024687.206,6526744.459000001,7028801.712,7530858.965,8032916.218,8534973.471,9037030.724000001,9539087.977,10041145.23],"counts":[4436,3,4,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2]}},{"benchmark_id":"stress_ng:switch","name":"stress-ng switch","description":"Start N workers that force context switching between two mutually blocking/unblocking tied processes. By default message passing over a pipe is used, but different methods are available. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"switch","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4453,"count_servers":2227,"histogram":{"breakpoints":[10858.79,6038332.7935,12065806.796999998,18093280.800499998,24120754.803999998,30148228.807499997,36175702.811,42203176.8145,48230650.817999996,54258124.821499996,60285598.824999996,66313072.828499995,72340546.832,78368020.8355,84395494.839,90422968.8425,96450442.846,102477916.8495,108505390.853,114532864.8565,120560338.86],"counts":[3843,262,145,58,40,21,21,9,21,3,11,1,2,3,1,1,5,2,3,1]}},{"benchmark_id":"stress_ng:timermix","name":"stress-ng timermix","description":"Start N workers creating timer and itimer signals at a high rate, this can create a many thousands of timer clock interrupts per second. Each signal that gets handled is counted as a bogo-operation. For timers, the following clocks types (where available) are used: CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, CLOCK_THREAD_CPUTIME_ID, CLOCK_BOOTTIME and CLOCK_TAI. For itimers, the following interval timer types are used: ITIMER_REAL, ITIMER_VIRTUAL and ITIMER_PROF. Some systems may support none or a subset of these timer or itimer types. The frequency of the itimers is auto-adjusted to try and maximize the timer interrupt rate. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"timermix","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[14026.23,9900636.7235,19787247.217,29673857.7105,39560468.203999996,49447078.6975,59333689.19099999,69220299.68450001,79106910.178,88993520.6715,98880131.165,108766741.6585,118653352.152,128539962.6455,138426573.139,148313183.6325,158199794.126,168086404.61949998,177973015.11299998,187859625.6065,197746236.1],"counts":[4098,221,65,26,16,6,2,7,1,1,4,0,1,0,1,4,0,0,3,2]}},{"benchmark_id":"stress_ng:tlb_shootdown","name":"stress-ng tlb-shootdown","description":"Start N workers that force Translation Lookaside Buffer (TLB) shootdowns. This is achieved by creating up to 16 child processes that all share a region of memory and these processes are shared amongst the available CPUs. The processes adjust the page mapping settings causing TLBs to be force flushed on the other processors, causing the TLB shootdowns. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"tlb_shootdown","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[617.03,31051.000499999995,61484.97099999999,91918.94149999999,122352.91199999998,152786.88249999998,183220.85299999997,213654.82349999997,244088.79399999997,274522.7645,304956.735,335390.7055,365824.676,396258.6465,426692.61699999997,457126.58749999997,487560.55799999996,517994.52849999996,548428.499,578862.4694999999,609296.44],"counts":[3252,426,241,159,103,70,54,65,40,28,7,6,3,1,0,0,0,1,1,1]}},{"benchmark_id":"stress_ng:tree","name":"stress-ng tree","description":"Start N workers that exercise tree data structures. The default is to add, find and remove 250000 64 bit integers into AVL (avl), Red-Black (rb), Splay (splay), btree and binary trees. The intention of this stressor is to exercise memory and cache with the various tree operations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"tree","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4448,"count_servers":2225,"histogram":{"breakpoints":[0.2,15.5375,30.875,46.212500000000006,61.550000000000004,76.8875,92.22500000000001,107.5625,122.9,138.23749999999998,153.575,168.9125,184.25,199.5875,214.92499999999998,230.2625,245.6,260.9375,276.275,291.6125,306.95],"counts":[3504,354,183,123,86,46,27,24,36,15,19,5,7,0,0,0,5,2,9,3]}},{"benchmark_id":"stress_ng:trig","name":"stress-ng trig","description":"Start N workers that exercise sin, cos, sincos (where available) and tan libm trigonometric functions using float, double and long double floating point variants. Each function is exercised 10000 times per bogo-operation. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"trig","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[175.15,35349.328,70523.506,105697.684,140871.862,176046.04,211220.218,246394.39599999998,281568.574,316742.75200000004,351916.93000000005,387091.108,422265.286,457439.46400000004,492613.642,527787.8200000001,562961.998,598136.176,633310.354,668484.532,703658.7100000001],"counts":[3711,325,164,89,48,24,21,29,4,1,12,6,7,0,0,8,1,0,0,2]}},{"benchmark_id":"stress_ng:tsc","name":"stress-ng tsc","description":"Start N workers that read the Time Stamp Counter (TSC) 256 times per loop iteration (bogo operation). This exercises the tsc instruction for x86, the mftb instruction for ppc64, the rdcycle instruction for RISC-V, the tick instruction on SPARC and the rdtime.d instruction for Loong64. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"tsc","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4038,"count_servers":2019,"histogram":{"breakpoints":[80381.53,18678608.345000003,37276835.160000004,55875061.97500001,74473288.79,93071515.605,111669742.42000002,130267969.23500001,148866196.05,167464422.865,186062649.68,204660876.495,223259103.31000003,241857330.12500003,260455556.94000003,279053783.755,297652010.57,316250237.385,334848464.2,353446691.015,372044917.83],"counts":[3373,321,150,71,36,26,16,15,10,2,2,0,0,6,6,3,0,0,0,1]}},{"benchmark_id":"stress_ng:usersyscall","name":"stress-ng usersyscall","description":"Start N workers that exercise the Linux prctl userspace system call mechanism. A userspace system call is handled by a SIGSYS signal handler and exercised with the system call disabled (ENOSYS) and enabled (via SIGSYS) using prctl PR_SET_SYSCALL_USER_DISPATCH. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"usersyscall","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4038,"count_servers":2019,"histogram":{"breakpoints":[36537.57,1678406.635,3320275.6999999997,4962144.765000001,6604013.83,8245882.895,9887751.96,11529621.025,13171490.09,14813359.155,16455228.219999999,18097097.285,19738966.35,21380835.415,23022704.48,24664573.544999998,26306442.61,27948311.675,29590180.74,31232049.805,32873918.869999997],"counts":[2662,307,198,138,160,126,52,98,97,58,41,27,18,15,5,7,4,7,16,2]}},{"benchmark_id":"stress_ng:vdso","name":"stress-ng vdso","description":"Start N workers that repeatedly call each of the system call functions in the vDSO (virtual dynamic shared object). The vDSO is a shared library that the kernel maps into the address space of all user-space applications to allow fast access to kernel data to some system calls without the need of performing an expensive system call. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vdso","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4458,"count_servers":2229,"histogram":{"breakpoints":[5086216.5,1941839006.2095,3878591795.919,5815344585.6285,7752097375.338,9688850165.0475,11625602954.757,13562355744.466501,15499108534.176,17435861323.8855,19372614113.595,21309366903.3045,23246119693.014,25182872482.7235,27119625272.433002,29056378062.1425,30993130851.852,32929883641.5615,34866636431.271,36803389220.9805,38740142010.69],"counts":[3743,336,159,70,46,29,30,6,11,8,2,6,2,3,2,0,4,0,0,1]}},{"benchmark_id":"stress_ng:veccmp","name":"stress-ng veccmp","description":"Start N workers that perform various unsigned integer math comparison operations on various 128 bit vectors. A mix of integer vector comparison operations are performed on the following vectors: 16 x 8 bits, 8 x 16 bits, 4 x 32 bits, 2 x 64 bits and if supported 1 x 128 bits. The metrics produced by this mix depend on the processor architecture and the vector math optimisations produced by the compiler. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"veccmp","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[1899.0,280454.0225,559009.045,837564.0675000001,1116119.09,1394674.1125,1673229.1350000002,1951784.1575000002,2230339.18,2508894.2025,2787449.225,3066004.2475,3344559.2700000005,3623114.2925000004,3901669.3150000004,4180224.3375000004,4458779.36,4737334.3825,5015889.405,5294444.4275,5572999.45],"counts":[3595,317,183,105,75,44,29,34,18,5,15,3,0,5,4,11,0,6,1,2]}},{"benchmark_id":"stress_ng:vecfp","name":"stress-ng vecfp","description":"Start N workers that exercise floating point (single and double precision) addition, multiplication, division and negation on vectors of 128, 64, 32, 16 and 8 floating point values. The -v option will show the approximate throughput in millions of floating pointer operations per second for each operation. For x86, the gcc/clang target clones attribute has been used to produced vector optimizations for a range of mmx, sse, avx and processor features. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vecfp","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[168.58,22645.165,45121.75,67598.335,90074.92,112551.50499999999,135028.09,157504.675,179981.25999999998,202457.84499999997,224934.42999999996,247411.01499999998,269887.60000000003,292364.185,314840.77,337317.355,359793.94,382270.525,404747.11,427223.695,449700.27999999997],"counts":[3544,350,187,104,80,43,33,25,27,19,6,0,0,10,6,7,2,2,4,3]}},{"benchmark_id":"stress_ng:vecmath","name":"stress-ng vecmath","description":"Start N workers that perform various unsigned integer math operations on various 128 bit vectors. A mix of vector math operations are performed on the following vectors: 16 x 8 bits, 8 x 16 bits, 4 x 32 bits, 2 x 64 bits and where supported 1 x 128 bits. The metrics produced by this mix depend on the processor architecture and the vector math optimisations produced by the compiler. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vecmath","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[402.59,56922.210499999994,113441.83099999999,169961.4515,226481.072,283000.6925,339520.313,396039.9335,452559.554,509079.1745,565598.7949999999,622118.4154999999,678638.036,735157.6564999999,791677.2769999999,848196.8975,904716.5179999999,961236.1384999999,1017755.759,1074275.3795,1130795.0],"counts":[3620,300,175,106,71,45,17,40,24,10,8,8,0,2,4,9,6,2,2,3]}},{"benchmark_id":"stress_ng:vecshuf","name":"stress-ng vecshuf","description":"Start N workers that shuffle data on various 64 byte vectors comprised of 8, 16, 32, 64 and 128 bit unsigned integers. The integers are shuffled around the vector with 4 shuffle operations per loop, 65536 loops make up one bogo-op of shuffling. The data shuffling rates and shuffle operation rates are logged when using the -v option. This stressor exercises vector load, shuffle/permute, packing/unpacking and store operations. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vecshuf","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[62.96,42020.0265,83977.09300000001,125934.15950000001,167891.226,209848.2925,251805.359,293762.4255,335719.492,377676.55850000004,419633.62500000006,461590.6915,503547.75800000003,545504.8245,587461.891,629418.9575,671376.024,713333.0904999999,755290.157,797247.2235,839204.29],"counts":[4181,153,38,32,12,2,9,6,0,0,0,1,7,0,9,1,0,0,0,1]}},{"benchmark_id":"stress_ng:vecwide","name":"stress-ng vecwide","description":"Start N workers that perform various 8 bit math operations on vectors of 4, 8, 16, 32, 64, 128, 256, 512, 1024 and 2048 bytes. With the -v option the relative compute performance vs the expected compute performance based on total run time is shown for the first vecwide worker. The vecwide stressor exercises various processor vector instruction mixes and how well the compiler can map the vector operations to the target instruction set. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vecwide","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2226,"histogram":{"breakpoints":[2832.07,648023.146,1293214.222,1938405.2980000002,2583596.374,3228787.4499999997,3873978.526,4519169.602,5164360.678,5809551.754000001,6454742.83,7099933.906,7745124.982000001,8390316.058,9035507.134,9680698.21,10325889.286,10971080.362,11616271.438000001,12261462.514,12906653.59],"counts":[3758,347,141,79,35,31,9,6,22,3,8,10,2,0,0,0,0,0,0,1]}},{"benchmark_id":"stress_ng:vfork","name":"stress-ng vfork","description":"Start N workers continually vforking children that immediately exit. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vfork","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4452,"count_servers":2227,"histogram":{"breakpoints":[1941.33,33366.365000000005,64791.40000000001,96216.43500000001,127641.47000000002,159066.505,190491.54,221916.575,253341.61000000002,284766.6450000001,316191.68000000005,347616.715,379041.75000000006,410466.7850000001,441891.82000000007,473316.85500000004,504741.8900000001,536166.925,567591.9600000001,599016.995,630442.03],"counts":[1724,835,383,371,292,308,205,142,115,43,9,5,4,4,1,5,2,2,1,1]}},{"benchmark_id":"stress_ng:vm","name":"stress-ng vm","description":"Start N workers continuously calling mmap/munmap and writing to the allocated memory. Note that this can cause systems to trip the kernel OOM killer on Linux systems if not enough physical memory and swap is not available. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"vm","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4413,"count_servers":2222,"histogram":{"breakpoints":[293.1,350346.083,700399.066,1050452.049,1400505.0320000001,1750558.0150000001,2100610.998,2450663.981,2800716.964,3150769.947,3500822.93,3850875.913,4200928.896,4550981.879,4901034.862,5251087.845,5601140.828,5951193.811,6301246.794,6651299.777,7001352.76],"counts":[4222,81,19,5,10,6,7,13,13,11,4,4,0,1,3,4,2,1,2,5]}},{"benchmark_id":"stress_ng:wcs","name":"stress-ng wcs","description":"Start N workers that exercise various libc wide character string functions on random strings. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"wcs","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4456,"count_servers":2228,"histogram":{"breakpoints":[65007.6,7725123.321,15385239.042000001,23045354.763000004,30705470.484000005,38365586.205000006,46025701.92600001,53685817.64700001,61345933.36800001,69006049.089,76666164.81,84326280.531,91986396.252,99646511.973,107306627.694,114966743.415,122626859.136,130286974.85700001,137947090.578,145607206.299,153267322.02],"counts":[3597,330,197,90,70,37,38,30,26,4,10,3,3,0,2,6,8,2,0,3]}},{"benchmark_id":"stress_ng:x86syscall","name":"stress-ng x86syscall","description":"Start N workers that repeatedly exercise the x86-64 syscall instruction to call the getcpu, geteuid, getgid, getpid, gettimeofday and time system calls using the Linux vsyscall handler. Only for Linux. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"x86syscall","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4038,"count_servers":2019,"histogram":{"breakpoints":[508508.36,195233566.77350003,389958625.18700004,584683683.6005,779408742.014,974133800.4275001,1168858858.8409998,1363583917.2545,1558308975.668,1753034034.0815,1947759092.4950001,2142484150.9085,2337209209.322,2531934267.7355003,2726659326.149,2921384384.5625005,3116109442.9760003,3310834501.3895,3505559559.8030005,3700284618.2165003,3895009676.6300006],"counts":[3525,214,117,60,36,14,24,14,7,9,2,0,0,6,0,5,0,2,2,1]}},{"benchmark_id":"stress_ng:yield","name":"stress-ng yield","description":"Start N workers that call sched_yield. This stressor ensures that at least 2 child processes per CPU exercise sched_yield no matter how many workers are specified, thus always ensuring rapid context switching. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"yield","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4438,"count_servers":2225,"histogram":{"breakpoints":[226324.04,34833482.2755,69440640.511,104047798.7465,138654956.982,173262115.2175,207869273.45299998,242476431.6885,277083589.924,311690748.1595,346297906.39500004,380905064.6305,415512222.866,450119381.10150003,484726539.337,519333697.57250005,553940855.808,588548014.0435,623155172.2789999,657762330.5145,692369488.75],"counts":[3405,502,222,111,58,37,38,11,10,5,13,4,12,6,0,1,0,1,1,1]}},{"benchmark_id":"stress_ng:zero","name":"stress-ng zero","description":"Start N workers that exercise /dev/zero with read, lseek, ioctl and mmap calls. For just /dev/zero read benchmarking use the --zero-read option. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"zero","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4456,"count_servers":2228,"histogram":{"breakpoints":[334960.9,117670212.92000002,235005464.94000003,352340716.96000004,469675968.98,587011221.0,704346473.0200001,821681725.0400001,939016977.0600001,1056352229.08,1173687481.1000001,1291022733.1200001,1408357985.1400003,1525693237.1600003,1643028489.1800003,1760363741.2000003,1877698993.2200003,1995034245.2400002,2112369497.2600002,2229704749.28,2347040001.3],"counts":[3950,232,112,63,25,12,16,19,8,3,1,1,0,3,5,4,0,0,1,1]}},{"benchmark_id":"stress_ng:zlib","name":"stress-ng zlib","description":"Start N workers compressing and decompressing random data using zlib. Each worker has two processes, one that compresses random data and pipes it to another process that decompresses the data. This stressor exercises CPU, cache and memory. The score is the total bogo operations per second (in real time) based on wall clock run time.","framework":"stress_ng","measurement":"zlib","unit":"Bogo operations per second (ops/s)","higher_is_better":true,"status":"ACTIVE","configs":{"cores":{"description":"Single-Core or Multi-Core stress tests.","examples":["multi","single"]}},"count":4433,"count_servers":2222,"histogram":{"breakpoints":[0.2,1013.7375000000001,2027.275,3040.8125,4054.35,5067.8875,6081.425,7094.9625,8108.5,9122.0375,10135.575,11149.112500000001,12162.650000000001,13176.187500000002,14189.725,15203.2625,16216.800000000001,17230.3375,18243.875,19257.412500000002,20270.95],"counts":[3572,353,189,106,59,39,22,30,22,8,7,1,1,2,3,12,2,3,0,2]}},{"benchmark_id":"workload_profile:cache","name":"Workload profile: Cache Intensive","description":"Precomputed compound score for Cache Intensive workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 50% Redis RPS (pipeline=1, SET), 20% Redis RPS (pipeline=16, SET), 10% PassMark Memory Mark (composite), 10% Memory bandwidth (read, 16 MB ~ L3), 10% PassMark single-thread CPU. Rationale for component selection: In-memory key-value store workload, mixing direct Redis performance metrics with memory speed and latency benchmarks, and single-core CPU performance profiles.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3735,"count_servers":3735,"histogram":{"breakpoints":[0.011,0.7604500000000001,1.5099,2.2593500000000004,3.0088000000000004,3.7582500000000003,4.507700000000001,5.25715,6.006600000000001,6.756050000000001,7.5055000000000005,8.25495,9.0044,9.75385,10.5033,11.25275,12.0022,12.75165,13.501100000000001,14.25055,15.0],"counts":[1574,737,393,324,169,178,87,52,49,44,28,18,30,8,8,3,0,14,6,13]}},{"benchmark_id":"workload_profile:cicd","name":"Workload profile: CI/CD Build","description":"Precomputed compound score for CI/CD Build workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 50% Geekbench Clang compilation (multi-core), 10% Geekbench Clang compilation (single-core), 20% stress-ng div16 best-N cores, 5% PassMark integer math, 5% PassMark compression, 5% Brotli compression (multi-core, level 0), 5% PassMark string sorting. Rationale for component selection: Build performance is mainly driven by multi-core compilation throughput, but also bundles single-core compilation speed and general CPU performance, multi-core compression and text/scripting processing.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3742,"count_servers":3742,"histogram":{"breakpoints":[0.0085,0.9080749999999999,1.8076499999999998,2.7072249999999998,3.6068,4.506374999999999,5.405949999999999,6.305524999999999,7.205099999999999,8.104674999999999,9.004249999999999,9.903825,10.803399999999998,11.702974999999999,12.602549999999999,13.502124999999998,14.401699999999998,15.301274999999999,16.20085,17.100425,18.0],"counts":[1718,792,496,306,171,113,68,31,15,22,1,0,0,1,5,1,0,0,0,2]}},{"benchmark_id":"workload_profile:compute","name":"Workload profile: Compute Heavy Applications","description":"Precomputed compound score for Compute Heavy Applications workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 15% stress-ng div16 best-N cores, 10% stress-ng div16 single core, 20% PassMark CPU Mark (composite), 10% Memory bandwidth (read, 64 MB), 15% PassMark floating point, 15% PassMark AVX/SSE/FMA (SIMD), 10% PassMark integer math, 5% PassMark physics simulation. Rationale for component selection: Number-crunching workload augmenting raw CPU performance stressing, general CPU performance benchmarks, memory bandwidth, and pure math computation speed like floating point, integer, SIMD (AVX/SSE/FMA) operations.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3742,"count_servers":3742,"histogram":{"breakpoints":[0.011,0.81045,1.6098999999999999,2.40935,3.2088,4.00825,4.8077,5.60715,6.4066,7.20605,8.0055,8.80495,9.604399999999998,10.403849999999998,11.203299999999999,12.002749999999999,12.8022,13.60165,14.4011,15.20055,16.0],"counts":[1658,711,416,309,197,118,83,40,58,44,46,12,8,3,17,0,5,9,7,1]}},{"benchmark_id":"workload_profile:data_analysis","name":"Workload profile: Data Analysis","description":"Precomputed compound score for Data Analysis workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 70% PassMark CPU Mark (composite), 10% Gzip compression (single-core, level 5), 10% Memory bandwidth (read, 64 MB), 10% PassMark Memory Mark (composite). Rationale for component selection: Data analysis and ETL workloads are memory-bandwidth-bound and CPU-throughput-driven. The profile combines general CPU performance and memory bandwidth/latency as the primary drivers, supplemented by single-core compression speed as a proxy for serialisation-heavy ETL tasks.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3711,"count_servers":3711,"histogram":{"breakpoints":[0.013,0.32735000000000003,0.6417,0.9560500000000001,1.2704,1.58475,1.8991,2.21345,2.5278,2.84215,3.1565000000000003,3.47085,3.7852,4.09955,4.4139,4.72825,5.0426,5.35695,5.6713000000000005,5.985650000000001,6.300000000000001],"counts":[709,676,451,341,267,247,285,161,116,129,82,51,56,49,33,22,7,0,13,16]}},{"benchmark_id":"workload_profile:database","name":"Workload profile: Relational Database","description":"Precomputed compound score for Relational Database workloads. A weighted average of normalised scores, each normalised to [0, 1] across all servers in the dataset. Component weights: 35% PassMark in-memory DB operations, 30% PassMark memory latency (512 MB), 20% PassMark Memory Mark (composite), 15% PassMark single-thread CPU. Rationale for component selection: Relational database workload (PostgreSQL, MySQL, transactional OLTP). Direct DB operation throughput is the primary driver, followed by memory latency for index lookups and buffer pool access, memory subsystem performance for working-set throughput, and single-thread CPU for query execution.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"INACTIVE","configs":{},"count":0,"count_servers":0,"histogram":null},{"benchmark_id":"workload_profile:llm","name":"Workload profile: LLM Inference","description":"Precomputed compound score for LLM Inference workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 15% LLM text generation (SmolLM-135M, 128 tok), 15% LLM prompt processing (SmolLM-135M, 512 tok), 15% LLM text generation (Llama 7B, 128 tok), 15% LLM prompt processing (Llama 7B, 512 tok), 15% LLM text generation (Llama-3.3 70B, 128 tok), 15% LLM prompt processing (Llama-3.3 70B, 512 tok), 5% Memory bandwidth (read, 256 MB), 2% PassMark AVX/SSE/FMA (SIMD), 2% PassMark floating point. Rationale for component selection: VRAM and memory-bandwidth-bound LLM inference workload, using direct LLM speed benchmarks at three model sizes, and supplementing with raw memory bandwidth and SIMD performance benchmarks.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3416,"count_servers":3416,"histogram":{"breakpoints":[0.0045,0.954275,1.90405,2.8538250000000005,3.8036000000000003,4.753375,5.703150000000001,6.652925000000001,7.6027000000000005,8.552475000000001,9.50225,10.452025,11.401800000000001,12.351575,13.301350000000001,14.251125,15.2009,16.150675,17.100450000000002,18.050225,19.0],"counts":[2745,371,222,27,1,4,3,6,7,8,0,3,1,5,5,1,1,2,3,1]}},{"benchmark_id":"workload_profile:ml","name":"Workload profile: ML inference","description":"Precomputed compound score for CPU-based machine-learning inference workloads. A weighted average of normalised scores, each normalised to [0, 1] across all servers in the dataset. Component weights: 20% LLM text generation (llama-7b, 128 tokens), 15% memory bandwidth read (256 MB, bw_mem), 10% LLM prompt processing (llama-7b, 512 tokens), 10% LLM text generation (gemma-2b, 128 tokens), 10% PassMark Memory Mark (composite), 10% PassMark AVX/SSE/FMA (SIMD), 10% Geekbench object detection (multi-core), 5% PassMark floating point, 5% Geekbench background blur (multi-core), 5% Geekbench structure-from-motion (multi-core).","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"INACTIVE","configs":{},"count":0,"count_servers":0,"histogram":null},{"benchmark_id":"workload_profile:web","name":"Workload profile: Web Server","description":"Precomputed compound score for Web Server workloads. A weighted average (geometric mean) of benchmark scores compared to their medians: score = ∏ (x_i / m_i)^(w_i / Σw). The score of 1.0 represents a synthetic baseline server with the median performance of each component benchmark; 0.5 means roughly half the performance; and 2.0 means twice the performance of that reference profile. Component weights: 30% Static web RPS (1 KiB, 8 conn/vCPU), 20% Static web RPS (64 KiB, 8 conn/vCPU), 20% Static web throughput (256 KiB, 8 conn/vCPU), 20% OpenSSL AES-256-CBC (16 kB blocks), 5% Gzip compression (multi-core, level 5), 5% PassMark string sorting. Rationale for component selection: Primary workloads drivers are single-process static HTTP serving speed and throughput, text processing, TLS termination, and asset compression.","framework":"workload_profile","measurement":"score","unit":null,"higher_is_better":true,"status":"ACTIVE","configs":{},"count":3738,"count_servers":3738,"histogram":{"breakpoints":[0.011,0.6604500000000001,1.3099,1.9593500000000001,2.6088000000000005,3.2582500000000003,3.9077000000000006,4.557150000000001,5.206600000000001,5.856050000000001,6.5055000000000005,7.154950000000001,7.804400000000001,8.453850000000001,9.1033,9.75275,10.4022,11.05165,11.7011,12.35055,13.0],"counts":[1456,608,424,302,229,156,106,103,93,89,37,57,34,15,11,9,3,0,3,3]}}]