[webkit-dev] Bring back ARMv6 support to JSC

Caio Lima ticaiolima at gmail.com
Thu Jul 13 07:47:43 PDT 2017


Finally I got the results from the last benchmark run. The results
shows that the speed-ups are considerable comparing with CLoop
version, since we get faster results in a big number of tests and
regress in a minor number of scripts. I would like to get feedback
from you as well, but IMHO enabling JIT for ARMv6 looks a good
improvement step and the amount of code we are touching in current
trunk code to make it possible is small.

The results are attached and I also uploaded them in
https://bugs.webkit.org/show_bug.cgi?id=172765.

PS.: Some test cases (bigswitch-indirect-symbol-or-undefined,
bigswitch-indirect-symbol, bigswitch, etc) are failing now and I'm
already investigating the source of problem to fix them.

Regards,
Caio.

2017-07-05 22:54 GMT-03:00 Filip Pizlo <fpizlo at apple.com>:
> To be clear, I’m concerned that the 32-bit JIT backends have such bad tuning for these embedded platforms that it’s just pure badness. Until you can prove that you can change this, I think that porting should focus on making the cloop great. Then, we can rip out support for weird CPUs rather than bringing it back.
>
> -Filip
>
>> On Jul 5, 2017, at 6:14 PM, Caio Lima <ticaiolima at gmail.com> wrote:
>>
>> 2017-07-05 18:25 GMT-03:00 Filip Pizlo <fpizlo at apple.com>:
>>> You need to establish that the JIT is a performance progression over the LLInt on ARMv6. I am opposed to more ARMv6 patches landing until there is some evidence provided that you’re actually getting speed-ups.
>>
>> It makes sense. I can get these numbers related to JIT.
>>
>> BTW, there is a Patch that isn't JIT related
>> (https://bugs.webkit.org/show_bug.cgi?id=172766).
>>
>> Regards,
>> Caio.
>>
>>> -Filip
>>>
>>>> On Jun 13, 2017, at 6:48 PM, Caio Lima <ticaiolima at gmail.com> wrote:
>>>>
>>>> Hi All.
>>>>
>>>> Some of you guys might know me through the work I have been doing in
>>>> JSC. The experience working with WebKit has been great so far, thank
>>>> you for the reviews!
>>>>
>>>> Since 1st May, we at Igalia have been working on bring back the ARMv6
>>>> support into JSC. We already have commits into our downstream branch
>>>> port[2] that fixes some compile/runtime errors when building JSC to
>>>> ARMv6 and also fixes some bugs. However, this branch is not synced
>>>> with WebKit upstream tree and I would like to pursue the upstreaming
>>>> of this ARMv6/JSC support to WebKit.
>>>>
>>>> As a long shot, we are planning to maintain the ARMv6 support and make
>>>> tests run as green as possible. Also, it's our goal make ARMv6 support
>>>> not interfere with other ARM versions support code negatively and we
>>>> will be in charge of implement platform-specific fixes/features for
>>>> JSC/ARM6, this way no imposing burden to the rest of the community.
>>>>
>>>> To keep track of work to be done, I've create a meta-bug in
>>>> bugzilla[3] and it's going to be used firstly to organize the commits
>>>> from our downstream branch, but pretty soon I'm going to create issues
>>>> related with javascriptcore-test failures and send patches to fix
>>>> them. We have already submitted 3 patches (they are marked as
>>>> dependence of [3]) that fixes ARMv6 into LLInt and JIT layers and got
>>>> a round of review into them.
>>>>
>>>> Best Regards,
>>>> Caio.
>>>>
>>>> [1] - https://www.igalia.com/about-us/coding-experience
>>>> [2] - https://github.com/WebPlatformForEmbedded/WPEWebKit
>>>> [3] - https://bugs.webkit.org/show_bug.cgi?id=172765
>>>> _______________________________________________
>>>> webkit-dev mailing list
>>>> webkit-dev at lists.webkit.org
>>>> https://lists.webkit.org/mailman/listinfo/webkit-dev
-------------- next part --------------
Benchmark report for SunSpider, LongSpider, V8Spider, Microbenchmarks, and SixSpeed on buildroot.

VMs tested:
"baseline" at /home/igalia/clima/webkit/WebKitBaselineBuild/Release/bin/jsc
"changes" at /home/igalia/clima/webkit/WebKitBuild/Release/bin/jsc

Collected 4 samples per benchmark/VM, with 4 VM invocations per benchmark. Emitted a call to gc() between sample
measurements. Used 1 benchmark iteration per VM invocation for warm-up. Used the jsc-specific preciseTime() function to get
microsecond-level timing. Reporting benchmark execution times with 95% confidence intervals in milliseconds.

                                                      baseline                  changes                                      
SunSpider:
   3d-cube                                       653.1262+-15.7953    !   1030.1705+-8.7283        ! definitely 1.5773x slower
   3d-morph                                      966.5934+-85.3047    ^    416.0468+-15.0777       ^ definitely 2.3233x faster
   3d-raytrace                                  1695.6381+-81.7207    !   2577.3122+-55.1663       ! definitely 1.5200x slower
   access-binary-trees                           648.9722+-64.7831         590.8699+-123.7847        might be 1.0983x faster
   access-fannkuch                               902.1701+-2.5893     ^    362.0073+-8.8704        ^ definitely 2.4921x faster
   access-nbody                                  535.7940+-12.1597    !   6683.9580+-437.6794      ! definitely 12.4749x slower
   access-nsieve                                 287.2592+-2.6465     ^    111.3273+-4.5024        ^ definitely 2.5803x faster
   bitops-3bit-bits-in-byte                      477.6718+-56.6748    ^     66.3021+-2.4835        ^ definitely 7.2045x faster
   bitops-bits-in-byte                           784.8725+-16.9934    ^     93.5233+-0.5927        ^ definitely 8.3923x faster
   bitops-bitwise-and                            701.2842+-1.1635     ^     90.6495+-0.8907        ^ definitely 7.7362x faster
   bitops-nsieve-bits                           1420.8232+-189.2688   ^    205.3207+-3.3373        ^ definitely 6.9200x faster
   controlflow-recursive                         494.8068+-39.2328    ^    184.0805+-2.5487        ^ definitely 2.6880x faster
   crypto-aes                                    787.5768+-34.6182    ^    604.1757+-8.8003        ^ definitely 1.3036x faster
   crypto-md5                                    633.0686+-36.9267    ?    639.1289+-15.8161       ?
   crypto-sha1                                   512.8978+-41.0676    ?    542.7040+-14.6138       ? might be 1.0581x slower
   date-format-tofte                            1953.9508+-93.6039    ^   1320.2947+-14.8026       ^ definitely 1.4799x faster
   date-format-xparb                            2349.0628+-36.6217    ^   1432.4960+-27.2060       ^ definitely 1.6398x faster
   math-cordic                                  1098.8075+-120.9166   ^    187.0942+-4.6486        ^ definitely 5.8730x faster
   math-partial-sums                            1006.0665+-60.5951    ^    592.6258+-29.8953       ^ definitely 1.6976x faster
   math-spectral-norm                            536.8810+-29.9263    ^    137.2111+-2.3072        ^ definitely 3.9128x faster
   regexp-dna                                   4252.4767+-10.6992    ^    228.6746+-1.9078        ^ definitely 18.5962x faster
   string-base64                                1852.6944+-50.0164    ^   1376.8703+-121.5084      ^ definitely 1.3456x faster
   string-fasta                                 3238.6278+-189.2283   ^    879.5948+-27.1438       ^ definitely 3.6820x faster
   string-tagcloud                              2074.5202+-19.3618    ^   1612.0284+-23.3098       ^ definitely 1.2869x faster
   string-unpack-code                           4855.7548+-177.3487   ^   3488.0035+-65.7473       ^ definitely 1.3921x faster
   string-validate-input                        2021.5053+-72.5748    ^   1437.7668+-45.2554       ^ definitely 1.4060x faster

   <arithmetic>                                 1413.1886+-12.5785    ^   1034.2399+-28.9202       ^ definitely 1.3664x faster

                                                      baseline                  changes                                      
LongSpider:
   3d-cube                                    356926.9083+-4058.9499  ^ 148358.0785+-2017.3457     ^ definitely 2.4058x faster
   3d-morph                                   194279.1884+-22141.0502 ^  50578.4452+-70.9665       ^ definitely 3.8411x faster
   3d-raytrace                                501531.4777+-14714.1189 ? 551882.3385+-40195.2662    ? might be 1.1004x slower
   access-binary-trees                        763149.6946+-30136.9512 ^ 644038.3804+-26369.7738    ^ definitely 1.1849x faster
   access-fannkuch                            109636.1643+-239.7688   ^  12999.7505+-12.7945       ^ definitely 8.4337x faster
   access-nbody                               273781.3323+-7548.6049  !3304822.4742+-406113.7363    ! definitely 12.0710x slower
   access-nsieve                               44594.2935+-503.4540   ^  10015.7337+-191.2975      ^ definitely 4.4524x faster
   bitops-3bit-bits-in-byte                    44061.4566+-5490.3023  ^   1174.2220+-1.5139        ^ definitely 37.5240x faster
   bitops-bits-in-byte                         76626.0073+-3489.6436  ^   3798.1978+-3.1794        ^ definitely 20.1743x faster
   bitops-nsieve-bits                         365986.1017+-26645.7982 ^  30291.4443+-120.5542      ^ definitely 12.0822x faster
   controlflow-recursive                      252760.3098+-49459.0049 ^  18230.3327+-58.9663       ^ definitely 13.8648x faster
   crypto-aes                                 429359.5789+-9579.7276  ^  82054.9462+-1850.0641     ^ definitely 5.2326x faster
   crypto-md5                                 799652.0730+-12756.7085 ^ 439746.5326+-29768.0097    ^ definitely 1.8184x faster
   crypto-sha1                               1397370.8230+-37526.5797 ^ 686865.1396+-36551.6104    ^ definitely 2.0344x faster
   date-format-tofte                          218845.1415+-10537.7639 ^  88401.5593+-1658.0319     ^ definitely 2.4756x faster
   date-format-xparb                          530229.6382+-2827.1556  ^ 190691.8006+-6501.4257     ^ definitely 2.7806x faster
   hash-map                                   183575.9942+-3736.3626    183103.8812+-27511.5416    
   math-cordic                                564654.1541+-30594.4789 ^  35824.1143+-196.7792      ^ definitely 15.7618x faster
   math-partial-sums                          156271.4317+-6092.6686  ^  50824.4490+-2229.8342     ^ definitely 3.0747x faster
   math-spectral-norm                         581927.6265+-35162.1204 ^  26459.6221+-7.5553        ^ definitely 21.9930x faster
   string-base64                              290770.6435+-7910.4432  ^ 163967.5855+-12615.8174    ^ definitely 1.7733x faster
   string-fasta                               317164.7017+-8882.2156  ^ 149727.4733+-5882.9934     ^ definitely 2.1183x faster
   string-tagcloud                             60878.6467+-1346.1151  ^  40193.2995+-1920.9613     ^ definitely 1.5146x faster

   <geometric>                                259079.6929+-4993.3809  ^  74114.3395+-275.9867      ^ definitely 3.4957x faster

                                                      baseline                  changes                                      
V8Spider:
   crypto                                      22005.2845+-120.2493   ^  14867.2621+-1121.3117     ^ definitely 1.4801x faster
   deltablue                                   77756.4158+-7857.5386  ! 214395.3790+-18806.9542    ! definitely 2.7573x slower
   earley-boyer                                36035.0571+-1410.5849  !  50161.4739+-5951.9049     ! definitely 1.3920x slower
   raytrace                                    22073.2050+-1319.2711  !  43119.4532+-2685.6996     ! definitely 1.9535x slower
   regexp                                      38068.2572+-441.6150   ^  14225.3270+-212.7467      ^ definitely 2.6761x faster
   richards                                    76123.7797+-4769.7961  ! 213400.9353+-4993.4587     ! definitely 2.8033x slower
   splay                                       17955.4843+-452.2673   ^  15606.9646+-1467.0510     ^ definitely 1.1505x faster

   <geometric>                                 35468.2392+-215.2154   !  44111.1508+-1375.9162     ! definitely 1.2437x slower

                                                      baseline                  changes                                      
Microbenchmarks:
   object-lshift                                 730.4243+-2.0566     ^    179.8896+-0.9537        ^ definitely 4.0604x faster
   new-array-buffer-push                        3099.8879+-169.2923   ^    477.0817+-43.8081       ^ definitely 6.4976x faster
   megamorphic-load                             9867.1090+-697.3787   ^   4623.5265+-377.1641      ^ definitely 2.1341x faster
   external-arguments-putbyval                   680.1688+-13.0096    ^    329.0580+-20.3883       ^ definitely 2.0670x faster
   inlined-put-by-id-transition                38179.4697+-3183.2273  ^    855.1687+-24.7333       ^ definitely 44.6455x faster
   repeat-multi-get-by-offset                  48699.0353+-6897.1500  ^  17897.7770+-5928.2454     ^ definitely 2.7210x faster
   fold-multi-put-by-offset-to-put-by-offset
                                                5706.0948+-1816.4584  !  15889.9393+-1591.2766     ! definitely 2.7847x slower
   ftl-polymorphic-bitand                      55432.0249+-945.5272   ^  23639.5763+-692.7982      ^ definitely 2.3449x faster
   string-concat-pair-object                    6166.9778+-104.5986   ^    124.1670+-1.2966        ^ definitely 49.6668x faster
   regexp-last-index                           23613.2712+-5131.1868  ^    523.2730+-2.6599        ^ definitely 45.1261x faster
   generator-function-create                   35444.7366+-2930.5231  ^    842.1036+-5.7421        ^ definitely 42.0907x faster
   splice-to-remove                             2860.9720+-236.9758   ?   3052.0700+-136.5590      ? might be 1.0668x slower
   prototype-access-with-mutating-prototype     1171.8148+-5.1471     !   3034.2277+-370.7340      ! definitely 2.5893x slower
   poly-chain-access                            2377.5423+-252.7545   ?   2814.4113+-579.3792      ? might be 1.1837x slower
   eval-cached                                  7286.9973+-243.1694   ^   3345.7043+-180.9394      ^ definitely 2.1780x faster
   string-repeat-resolving-fixed                2446.9488+-22.9525    ^   1052.2197+-6.6940        ^ definitely 2.3255x faster
   to-number-string-number-string-number         722.0838+-24.1093    ^    621.5494+-9.8688        ^ definitely 1.1617x faster
   infer-closure-const-then-reenter            48680.0755+-788.9022   ^   1271.2537+-10.9138       ^ definitely 38.2930x faster
   polymorphic-structure                       17076.2340+-3259.3436     13982.4855+-2355.5776       might be 1.2213x faster
   get_callee_monomorphic                       1986.4050+-127.3388   ^    179.2468+-1.6026        ^ definitely 11.0820x faster
   varargs-call                                15017.1918+-811.4069   ^   6325.7653+-609.6466      ^ definitely 2.3740x faster
   regexp-prototype-split-observable-side-effects3-global
                                                  27.0350+-0.3884     ?     27.7054+-0.5087        ? might be 1.0248x slower
   number-to-string-with-add                    4347.3930+-253.1933   ^   1225.4587+-138.0601      ^ definitely 3.5476x faster
   Int32Array-alloc-large                        582.0690+-9.0589     ^    552.6124+-2.9848        ^ definitely 1.0533x faster
   object-rshift                                 729.8185+-3.3358     ^    179.5209+-0.6240        ^ definitely 4.0654x faster
   regexp-prototype-split-observable-side-effects3-sticky
                                                  27.2860+-0.4010     ?     27.4721+-0.3461        ?
   arity-mismatch-inlining                       286.1178+-23.5237    ^     57.1741+-0.6660        ^ definitely 5.0043x faster
   get-by-id-self-or-proto                     23754.7552+-2717.9146  ^  10667.8695+-3368.2702     ^ definitely 2.2268x faster
   fold-put-by-val-with-symbol-to-multi-put-by-offset
                                               27107.9640+-1108.6834  ^  11445.4460+-1154.8298     ^ definitely 2.3684x faster
   int-or-other-abs-then-get-by-val             4300.4700+-173.1476   ^    854.2415+-182.1121      ^ definitely 5.0343x faster
   strcat-const                                15219.7550+-1471.3528  ^    254.9742+-0.5333        ^ definitely 59.6914x faster
   int-or-other-mod-then-get-by-val             3050.6641+-174.0527   ^    910.1525+-61.9358       ^ definitely 3.3518x faster
   object-xor                                    730.2714+-1.5968     ^    181.1447+-1.1391        ^ definitely 4.0314x faster
   array-with-double-mul-add                    1504.7880+-6.9491     ^    284.9860+-2.2805        ^ definitely 5.2802x faster
   object-int-sub-array                         5654.9061+-10.8129    ^    817.7244+-0.7430        ^ definitely 6.9154x faster
   arrowfunction-call                           3358.0438+-317.0021   ^    343.1718+-2.5744        ^ definitely 9.7853x faster
   string-prototype-search-observable-side-effects3
                                                  29.3443+-0.2945     ?     29.6895+-0.1822        ? might be 1.0118x slower
   sink-function                                7531.0644+-868.4734   ^    426.5092+-25.1145       ^ definitely 17.6574x faster
   infer-closure-const-then-put-to-scope       48169.4843+-6110.9192  ^   1251.1862+-1.9590        ^ definitely 38.4991x faster
   ftl-library-inlining                        11225.0390+-71.6599    ^   2159.2035+-2.8708        ^ definitely 5.1987x faster
   arguments                                   10090.7103+-1063.6446  ^    897.2072+-3.1915        ^ definitely 11.2468x faster
   to-number-constructor-only-string             396.5125+-16.3401    ^    288.7760+-10.7346       ^ definitely 1.3731x faster
   undefined-property-access                  480287.5185+-61913.6903 ? 529322.4585+-98611.0005    ? might be 1.1021x slower
   infer-closure-const-then-put-to-scope-no-inline
                                                8942.2112+-953.5010   ^    559.5113+-7.7866        ^ definitely 15.9822x faster
   sparse-set                                  10876.7700+-3258.1122  !  20953.4446+-4807.6900     ! definitely 1.9264x slower
   is-undefined-fold                            8771.7899+-1488.2492  ^     84.5767+-2.4882        ^ definitely 103.7140x faster
   object-or                                     730.5008+-3.4462     ^    180.2901+-0.7604        ^ definitely 4.0518x faster
   inlined-put-by-val-with-string-transition
                                               28487.3363+-1470.1256  ^  22039.7997+-1120.5889     ^ definitely 1.2925x faster
   bound-function-call                         12859.0057+-990.7983   ^   2616.3555+-284.3078      ^ definitely 4.9149x faster
   mod-boolean                                  2239.3965+-682.8908   ^    272.0065+-3.9174        ^ definitely 8.2329x faster
   polymorphic-put-by-val-with-symbol         139967.2917+-4725.6623  ^  90061.2368+-5768.1622     ^ definitely 1.5541x faster
   polyvariant-monomorphic-get-by-id           18493.2385+-1018.3787  ^   9478.6888+-2008.3765     ^ definitely 1.9510x faster
   global-code-ftl                             66096.5843+-6294.5337  ^   3594.6697+-30.1088       ^ definitely 18.3874x faster
   Int32Array-alloc                             1862.5422+-157.5159   ^    171.9268+-2.7953        ^ definitely 10.8333x faster
   int-or-other-mul-then-get-by-val             3594.7828+-273.1197   ^   1442.2570+-121.3842      ^ definitely 2.4925x faster
   to-int32-boolean                            13183.1404+-955.9496   ^   1480.3737+-20.0203       ^ definitely 8.9053x faster
   fold-multi-put-by-offset-to-poly-put-by-offset
                                               36912.9064+-787.4184   ^  14672.9978+-1108.3398     ^ definitely 2.5157x faster
   Float32Array-to-Float64Array-set            82198.2607+-2912.1677  ^  50270.4181+-2557.2692     ^ definitely 1.6351x faster
   string-replace                              37133.1353+-1953.5955  ^  28326.7853+-1381.7226     ^ definitely 1.3109x faster
   map-rehash                                   4459.1221+-212.6906   ^   3492.1640+-140.4855      ^ definitely 1.2769x faster
   int-or-other-sub                             3772.4975+-272.2711   ^    493.0876+-3.7040        ^ definitely 7.6508x faster
   super-get-by-val-with-this-monomorphic      15746.4275+-532.1597   ^  11386.5954+-141.8291      ^ definitely 1.3829x faster
   untyped-string-from-char-code                5278.9001+-1117.5503  ^    947.1123+-358.8800      ^ definitely 5.5737x faster
   string-prototype-search-observable-side-effects
                                                  59.4411+-0.5443     !     62.7440+-2.0014        ! definitely 1.0556x slower
   super-get-by-id-with-this-monomorphic       14436.3251+-811.6528   ^  10711.6019+-440.2811      ^ definitely 1.3477x faster
   inline-arguments-local-escape                3457.2910+-167.5565   ^    259.7466+-4.0221        ^ definitely 13.3102x faster
   string-concat-convert                      294756.2115+-17830.1093 ^  29253.0803+-3094.2327     ^ definitely 10.0761x faster
   v8-regexp-search                            43162.9980+-932.0570   ^  16990.5453+-546.3826      ^ definitely 2.5404x faster
   neg-boolean                                  1512.6205+-363.3713   ^    115.5342+-1.5742        ^ definitely 13.0924x faster
   string-concat-long                          73804.4478+-4462.1077  ^  22310.9723+-963.5702      ^ definitely 3.3080x faster
   object-values                                3242.6137+-376.2631   ?   3298.5067+-524.2693      ? might be 1.0172x slower
   varargs-inline                              16945.8605+-654.1128   ^   6311.1398+-1055.4152     ^ definitely 2.6851x faster
   div-boolean-double                           1574.6725+-325.0723   ^    147.0625+-1.8440        ^ definitely 10.7075x faster
   arrowfunciton-direct-arguments                607.1694+-54.2758    ^     58.9067+-0.5892        ^ definitely 10.3073x faster
   for-of-array                                32458.0769+-728.3785   ^   7902.9647+-150.0351      ^ definitely 4.1071x faster
   basic-set                                    2200.9485+-37.3995    ^   1807.1627+-69.0544       ^ definitely 1.2179x faster
   in-one-case-false                           21349.2148+-1016.7425  ^   5706.0805+-518.6649      ^ definitely 3.7415x faster
   get-by-id-chain-from-try-block                500.2712+-1.7033     !   3612.0505+-848.3587      ! definitely 7.2202x slower
   get-by-val-with-symbol-bimorphic-check-structure-elimination-simple
                                                4131.7913+-320.4971   ^   2002.4891+-480.1153      ^ definitely 2.0633x faster
   double-get-by-val-out-of-bounds              1680.6529+-83.1149    ^    523.2930+-54.1271       ^ definitely 3.2117x faster
   getter                                      38209.8155+-2318.3223  ^  26351.8929+-1665.1007     ^ definitely 1.4500x faster
   object-entries                              27302.8724+-868.0869   ^  20156.5521+-814.1352      ^ definitely 1.3545x faster
   for-of-iterate-array-values                   926.1870+-114.9371   !   3201.4265+-346.0833      ! definitely 3.4566x slower
   lazy-array-species-watchpoints              10131.8355+-399.2662   ^   6289.9063+-77.7236       ^ definitely 1.6108x faster
   sparse-conditional                            678.4722+-82.5564    ^     82.0593+-1.6801        ^ definitely 8.2681x faster
   inline-arguments-aliased-access              3823.3063+-408.2241   ^    259.2529+-2.1245        ^ definitely 14.7474x faster
   ArrayBuffer-Int8Array-alloc-long-lived-buffer
                                                9625.1923+-190.2821   ^   7359.3441+-87.4601       ^ definitely 1.3079x faster
   regexp-prototype-search-observable-side-effects
                                                  49.9802+-0.6721     !     52.8455+-1.2741        ! definitely 1.0573x slower
   cell-argument                                2320.1814+-4.1159     !  11576.7823+-1864.8639     ! definitely 4.9896x slower
   gcse                                         3403.0600+-299.0374   ^    251.3895+-14.5377       ^ definitely 13.5370x faster
   polymorphic-put-by-val-with-string         125369.7232+-13170.8839 ^  89730.2427+-11841.6074    ^ definitely 1.3972x faster
   to-number-only-number                          50.2055+-3.2674     ^     38.0085+-0.6380        ^ definitely 1.3209x faster
   licm-dragons-out-of-bounds                  15491.9263+-66.6784    ^   2024.6905+-4.7258        ^ definitely 7.6515x faster
   put-by-id-replace-and-transition            23530.4686+-701.6883   ^    702.2092+-21.9399       ^ definitely 33.5092x faster
   int-or-other-neg-then-get-by-val             3334.2357+-408.5278   !   7857.3929+-702.5605      ! definitely 2.3566x slower
   gcse-poly-get-less-obvious                  65797.9012+-9981.6877  ^  33592.0987+-7505.6640     ^ definitely 1.9587x faster
   ArrayBuffer-Int8Array-alloc-large-long-lived
                                                7897.8430+-119.6165   ^   6640.5087+-31.3353       ^ definitely 1.1893x faster
   string-prototype-split-observable-side-effects3-global
                                                  30.7375+-0.3176     ?     31.2469+-0.2513        ? might be 1.0166x slower
   int-or-other-neg-zero-then-get-by-val       10087.6455+-401.9956   ^   1665.5428+-9.3379        ^ definitely 6.0567x faster
   typed-array-subarray                        61963.5508+-2299.4508  ^  22782.7941+-253.8536      ^ definitely 2.7198x faster
   is-string-fold                               8721.6014+-2081.1427  ^     83.9356+-0.8660        ^ definitely 103.9082x faster
   new-array-dead                              73871.7710+-7079.3973  ^   2912.9975+-21.7030       ^ definitely 25.3594x faster
   abc-forward-loop-equal                      33161.3875+-19.3429    ^   3585.4593+-8.3919        ^ definitely 9.2489x faster
   poly-chain-access-different-prototypes-simple
                                                2354.9214+-263.2863   ?   2438.8503+-239.4233      ? might be 1.0356x slower
   array-with-double-sum                         687.5396+-2.6291     ^    149.5155+-2.5638        ^ definitely 4.5985x faster
   ftl-polymorphic-bitor                       55808.9620+-1839.0963  ^  24769.3273+-643.8521      ^ definitely 2.2531x faster
   obvious-sink-pathology-taken               118453.0797+-11031.0269 ^  15087.1526+-78.9986       ^ definitely 7.8513x faster
   string-repeat-not-resolving-no-inline        2297.0414+-108.1484   ^    467.3000+-11.7330       ^ definitely 4.9156x faster
   deltablue-varargs                            7778.9645+-127.8324   ^   6560.5722+-203.3169      ^ definitely 1.1857x faster
   regexp-prototype-search-observable-side-effects2
                                                  25.0488+-0.6602     ?     25.0596+-0.5525        ?
   arguments-named-and-reflective              10339.9865+-743.0085   ^   1032.9163+-4.0617        ^ definitely 10.0105x faster
   global-isNaN                                23897.8312+-5142.7143  ^   1711.4969+-2.3218        ^ definitely 13.9631x faster
   number-to-string-with-add-empty              3572.6903+-104.6430   ^   1195.3116+-63.2229       ^ definitely 2.9889x faster
   number-to-string-with-add-in-loop           45685.6259+-3283.3721  ^  10418.8882+-903.4707      ^ definitely 4.3849x faster
   double-to-uint32-typed-array-no-inline       1376.7365+-119.8230   ^    198.0104+-2.8924        ^ definitely 6.9529x faster
   v8-raytrace-with-try-catch                  33779.7335+-597.4657   !  47395.0225+-1586.0329     ! definitely 1.4031x slower
   double-pollution-getbyval                    1147.4410+-4.0313     ^    232.3344+-4.8437        ^ definitely 4.9387x faster
   string-repeat-not-resolving-fixed            1466.4315+-60.1004    ^    447.5978+-8.6414        ^ definitely 3.2762x faster
   call-spread-call                            18734.9460+-297.1263   ^   8491.3627+-346.3244      ^ definitely 2.2064x faster
   string-prototype-split-observable-side-effects4
                                                  31.2770+-0.3383     ?     31.9419+-0.4066        ? might be 1.0213x slower
   int-or-other-add-then-get-by-val             4208.4098+-424.0390   ^    316.5892+-1.9156        ^ definitely 13.2930x faster
   direct-arguments-getbyval                     338.6414+-42.7333    ^     88.7913+-3.8403        ^ definitely 3.8139x faster
   array-prototype-forEach                     23290.2492+-512.8638   ^   1765.7498+-257.8577      ^ definitely 13.1900x faster
   obvious-sink-pathology                      72552.2109+-13547.2927 ^   8481.0833+-16.7426       ^ definitely 8.5546x faster
   infer-one-time-closure                       5216.2267+-6.3766     ^    369.1122+-2.8041        ^ definitely 14.1318x faster
   constant-test                                6128.4895+-615.5381   ^    227.7897+-2.6181        ^ definitely 26.9042x faster
   string-get-by-val-out-of-bounds-insane       1026.6083+-23.5869    ^    734.6335+-26.7365       ^ definitely 1.3974x faster
   fold-multi-put-by-offset-to-replace-or-transition-put-by-offset
                                               46959.0685+-1128.2727  ^  17000.0914+-1928.6618     ^ definitely 2.7623x faster
   array-splice-contiguous                      1383.8440+-33.9461    ?   1455.7146+-82.5943       ? might be 1.0519x slower
   super-get-by-id-with-this-polymorphic       15138.2620+-489.7836   ^  10114.7645+-267.2126      ^ definitely 1.4966x faster
   direct-tail-call                            40369.6054+-3846.8915  ^   2579.5317+-2.5621        ^ definitely 15.6500x faster
   poly-stricteq                               24103.6041+-2479.5651  ^   4823.4250+-87.0618       ^ definitely 4.9972x faster
   call-spread-apply                           14715.7117+-279.6480   ^  11823.7367+-107.7089      ^ definitely 1.2446x faster
   template-string-array                        2896.3267+-267.7177   ^    332.5303+-5.5366        ^ definitely 8.7100x faster
   direct-arguments-possibly-overridden-length
                                                4846.9851+-495.9990   ^   3626.2311+-664.2816      ^ definitely 1.3366x faster
   fold-double-to-int                          28010.8617+-1474.7262  ^   1054.6566+-12.2813       ^ definitely 26.5592x faster
   tear-off-arguments                           3432.6177+-673.9998   ^    310.2558+-16.0053       ^ definitely 11.0638x faster
   cse-new-array-buffer                         2312.5360+-140.1802   ^    319.0578+-24.9543       ^ definitely 7.2480x faster
   new-array-buffer-dead                       56657.1262+-4259.8707  ^   2187.6305+-16.2777       ^ definitely 25.8989x faster
   fold-put-structure                           5767.0115+-1184.6112  !  14745.3398+-2326.7032     ! definitely 2.5568x slower
   to-lower-case                               32943.4738+-1779.8175  ^  18783.5085+-2189.2963     ^ definitely 1.7539x faster
   cse-new-array                                2222.1358+-72.0872    ^    324.3309+-40.0413       ^ definitely 6.8514x faster
   negative-zero-modulo                           27.6564+-0.9724     !     39.0403+-1.1471        ! definitely 1.4116x slower
   is-object-or-null-fold-tricky               13450.1055+-1442.0290  ^    161.1070+-3.6131        ^ definitely 83.4855x faster
   get_by_val-Int32Array                        2861.4890+-132.2814   ^   1384.1302+-112.5982      ^ definitely 2.0674x faster
   polymorphic-put-by-id                       12885.4937+-187.2818   ! 118494.8160+-22808.6885    ! definitely 9.1960x slower
   substring                                   27142.5095+-3334.1559  ^  14809.5862+-2256.6490     ^ definitely 1.8328x faster
   prevent-extensions-and-do-work               7338.1133+-5.4678     !  44318.5360+-7677.2812     ! definitely 6.0395x slower
   by-val-generic                               2910.4357+-136.0131   ^   1159.0912+-92.7437       ^ definitely 2.5110x faster
   generator-with-several-types                83361.6942+-1216.0377  ! 170666.4564+-14747.4893    ! definitely 2.0473x slower
   to-number-constructor-number-string-number-string
                                                1058.8076+-34.5004    ^    620.0702+-16.7000       ^ definitely 1.7076x faster
   mul-boolean-double                           1490.2922+-294.2825   ^    108.8425+-0.4506        ^ definitely 13.6922x faster
   setter-prototype                           246112.0674+-5947.6542  ! 276213.3282+-8533.1383     ! definitely 1.1223x slower
   for-of-iterate-array-entries                 6118.3039+-157.3312   !   8821.4163+-444.9586      ! definitely 1.4418x slower
   try-catch-get-by-val-cloned-arguments        1220.2919+-58.3140    ^    577.0907+-33.2182       ^ definitely 2.1146x faster
   direct-construct-arity-mismatch            115370.3330+-11283.4946 ^  32707.5746+-5396.9752     ^ definitely 3.5273x faster
   boolean-test                                 1145.1107+-214.0112   ^    206.5472+-2.6488        ^ definitely 5.5441x faster
   is-object-or-null-tricky-internal-function
                                               15142.6899+-950.5358   ^    340.6621+-2.6007        ^ definitely 44.4508x faster
   arrowfunciton-reference-arguments              87.5228+-6.8315     ^     49.4106+-0.4789        ^ definitely 1.7713x faster
   div-boolean                                  1367.7118+-386.2659   ^    198.1099+-1.1399        ^ definitely 6.9038x faster
   scoped-arguments-length                      4474.2788+-527.8304       3691.0658+-956.6789        might be 1.2122x faster
   unprofiled-licm                              8984.6313+-1.1146     ! 179122.3127+-20503.7651    ! definitely 19.9365x slower
   put-by-val-with-string-replace-and-transition
                                               24603.1812+-1743.9093  ^   6083.5401+-355.8356      ^ definitely 4.0442x faster
   sinkable-new-object-taken                  113561.5355+-12447.0519 ^  14008.6071+-120.2811      ^ definitely 8.1066x faster
   bigswitch-indirect-symbol-or-undefined      56813.5355+-11466.7709            ERROR             
   instanceof-bound                            10616.3065+-16.5617    ^   2164.3618+-43.6552       ^ definitely 4.9051x faster
   to-number-constructor-only-number              84.2982+-6.5103     ^     39.7617+-0.2866        ^ definitely 2.1201x faster
   apply-not-apply                             23798.4377+-3629.0447     20041.5842+-8831.3428       might be 1.1875x faster
   inline-arguments-access                      3474.4700+-330.8033   ^    257.3796+-1.5015        ^ definitely 13.4994x faster
   tan                                          9178.1996+-1622.3843  ^   3588.5543+-8.6149        ^ definitely 2.5576x faster
   global-var-const-infer-fire-from-opt           89.8117+-28.8148    !    134.7687+-2.6354        ! definitely 1.5006x slower
   fold-multi-get-by-offset-to-get-by-offset
                                                7987.9801+-659.7104   ^   5994.0672+-1167.0850     ^ definitely 1.3326x faster
   switch                                      10302.4965+-322.9739   ^   3154.0605+-160.2331      ^ definitely 3.2664x faster
   is-boolean-fold-tricky                       9863.5549+-1073.6566  ^    130.8519+-1.6341        ^ definitely 75.3795x faster
   generator-sunspider-access-nsieve             792.7946+-14.1835    !   1034.6393+-83.0642       ! definitely 1.3051x slower
   string-prototype-split-observable-side-effects3-multiline
                                                  31.0081+-1.0600     ?     31.3263+-0.3710        ? might be 1.0103x slower
   marsaglia-osr-entry                         34024.5972+-3392.7645  ^    827.2346+-1.2300        ^ definitely 41.1305x faster
   put-by-val-large-index-blank-indexing-type
                                                1121.4661+-19.2891    ^   1062.7999+-9.2470        ^ definitely 1.0552x faster
   Int32Array-Int8Array-view-alloc              3200.3615+-46.0556    ^   2272.9849+-62.8127       ^ definitely 1.4080x faster
   array-prototype-some                        24068.4292+-2363.5854  ^   1670.3887+-27.5607       ^ definitely 14.4089x faster
   Int16Array-bubble-sort                     162588.1645+-18519.2618 ^  58044.3864+-3033.2527     ^ definitely 2.8011x faster
   string-cons-tower                           34499.9876+-893.5638   ^    475.1865+-2.5789        ^ definitely 72.6031x faster
   v8-raytrace-with-empty-try-catch            22425.3820+-336.9444   !  45145.1620+-2984.5954     ! definitely 2.0131x slower
   HashMap-put-get-iterate-keys                18493.3700+-983.7089   ?  21831.4518+-2641.1004     ? might be 1.1805x slower
   simple-regexp-exec-folding                  18868.1039+-1073.5528     17623.9561+-1512.7353       might be 1.0706x faster
   DataView-custom-properties                  10888.8093+-173.3351   ^   9969.5775+-153.3594      ^ definitely 1.0922x faster
   array-access-polymorphic-structure           3271.8998+-178.8514   ^   1279.7475+-52.6061       ^ definitely 2.5567x faster
   assign-custom-setter                         3979.5278+-457.0198       3787.6194+-89.8555         might be 1.0507x faster
   hard-overflow-check                         25160.8932+-340.0850   ! 116008.9297+-37285.5431    ! definitely 4.6107x slower
   array-with-double-add                        1101.2285+-3.4247     ^    293.5468+-4.4796        ^ definitely 3.7515x faster
   is-function-fold-tricky                     14773.7375+-783.3895   ^    147.6055+-2.0648        ^ definitely 100.0894x faster
   register-pressure-from-osr                   6702.4728+-165.1002   !  35993.2134+-7424.4176     ! definitely 5.3701x slower
   simple-getter-access                       123382.0138+-7033.5678  ^  52005.2994+-2846.6916     ^ definitely 2.3725x faster
   cast-int-to-double                           5569.3876+-476.0751   ^    506.9398+-12.4475       ^ definitely 10.9863x faster
   is-array-for-proxy                           1455.8030+-131.4502   ^    259.5402+-67.2900       ^ definitely 5.6092x faster
   string-replace-empty                        29788.4800+-756.2814   ^  20872.3906+-1741.2539     ^ definitely 1.4272x faster
   to-number-constructor-string-number-string-number
                                                 866.1357+-24.1840    ^    633.5291+-21.1561       ^ definitely 1.3672x faster
   imul-int-only                                8331.1223+-3031.7388  ^    438.2853+-2.9524        ^ definitely 19.0084x faster
   many-repeat-stores                          78386.0793+-12.6343    ^  12307.0610+-104.2320      ^ definitely 6.3692x faster
   arrowfunction-call-in-class-constructor     66914.0227+-1754.4990  ^  23496.4097+-2329.2322     ^ definitely 2.8478x faster
   string-from-char-code                       17794.1786+-6413.0606  ^    838.9037+-2.2179        ^ definitely 21.2112x faster
   JSONP-negative-0                               22.5477+-0.7019           22.0266+-0.4299          might be 1.0237x faster
   string-repeat-single-resolving               1004.8174+-20.2253    ^    497.2618+-5.0869        ^ definitely 2.0207x faster
   infer-one-time-closure-ten-vars             26242.7803+-16.0880    ^    412.2166+-8.3125        ^ definitely 63.6626x faster
   sinkable-new-object                         73261.0659+-11736.5349 ^   8509.0519+-92.5960       ^ definitely 8.6098x faster
   string-concat-object                         5299.4507+-101.4725   ^    129.0418+-2.7634        ^ definitely 41.0677x faster
   make-rope-cse                                4074.4487+-303.7267   ^    233.9830+-6.2140        ^ definitely 17.4134x faster
   object-int-and-array                         5095.7944+-1.7201     ^    728.9215+-1.8376        ^ definitely 6.9909x faster
   get-by-val-out-of-bounds                     1493.5505+-49.2029    ^    366.7094+-90.6671       ^ definitely 4.0728x faster
   map-has-get-cse-opportunity                 69098.9522+-2689.1027  ^  54899.8909+-8392.3594     ^ definitely 1.2586x faster
   locale-compare                              11866.0526+-340.7623   ^   7578.3521+-267.7972      ^ definitely 1.5658x faster
   string-repeat-not-resolving                  2244.4911+-111.2806   ^    507.7511+-8.1855        ^ definitely 4.4205x faster
   map-for-of                                   3124.4797+-133.1603   !   6867.4103+-171.9067      ! definitely 2.1979x slower
   delay-tear-off-arguments-strictmode          1656.2805+-32.1689    !   2832.5616+-244.6932      ! definitely 1.7102x slower
   regexp-prototype-split-observable-side-effects3-multiline
                                                  27.0292+-0.2125     ?     27.6068+-0.5178        ? might be 1.0214x slower
   switch-string-basic-big                      9253.7305+-999.0008   ^   1254.2981+-3.9054        ^ definitely 7.3776x faster
   number-test                                  1163.1373+-97.4391    ^    206.0514+-2.0733        ^ definitely 5.6449x faster
   math-random                                  3100.7345+-1004.8932  ^    538.6253+-2.9151        ^ definitely 5.7568x faster
   temporal-structure                          15596.5735+-3117.6939     12205.1307+-3869.0956       might be 1.2779x faster
   array-prototype-map                         24236.4280+-1423.4484  ^   3109.1459+-362.9546      ^ definitely 7.7952x faster
   infer-one-time-deep-closure                 11803.9244+-12.3470    ^    743.2775+-1.7847        ^ definitely 15.8809x faster
   generator-fib                               27599.9198+-116.4155   !  52496.5048+-4193.1676     ! definitely 1.9021x slower
   put-by-val-with-symbol                      46637.8820+-2547.1138  ^  13734.0939+-1670.6675     ^ definitely 3.3958x faster
   rare-osr-exit-on-local                       7308.3721+-1172.7146  ^   1834.0070+-10.9511       ^ definitely 3.9849x faster
   string-equality                             22016.7833+-1107.9766  ^    670.7068+-2.5121        ^ definitely 32.8262x faster
   array-with-int32-or-double-sum                702.4210+-1.7066     ^    156.9680+-1.1012        ^ definitely 4.4749x faster
   string-repeat-arith                          3752.5573+-409.3871   ^   1350.8598+-287.0663      ^ definitely 2.7779x faster
   array-prototype-reduce                      23049.7733+-846.8282   ^   1739.6169+-29.9451       ^ definitely 13.2499x faster
   object-int-mul-array                         5093.2217+-3.1824     ^    729.3663+-1.3439        ^ definitely 6.9831x faster
   polymorphic-get-by-id                         617.0543+-17.8376    !   2052.2558+-393.5884      ! definitely 3.3259x slower
   get-by-val-with-string-proto-or-self        32312.1671+-1496.0077  ^  10890.5019+-4264.9687     ^ definitely 2.9670x faster
   get-by-val-with-symbol-quadmorphic-check-structure-elimination-simple
                                                4026.5815+-681.1404   ^   2081.3942+-441.7006      ^ definitely 1.9346x faster
   Int8Array-load                               8522.6945+-377.8456   ^   3948.8195+-154.6110      ^ definitely 2.1583x faster
   marsaglia-larger-ints                       89174.2040+-11159.4804 ^   3409.3066+-1.4340        ^ definitely 26.1561x faster
   large-int-captured                           2921.5325+-61.4848    ^    336.8384+-1.4421        ^ definitely 8.6734x faster
   string-char-code-at                         40918.5977+-2868.1435  ^  24082.7426+-3378.8044     ^ definitely 1.6991x faster
   super-get-by-val-with-this-polymorphic      15835.3000+-448.5942   ^  10637.8367+-238.2845      ^ definitely 1.4886x faster
   HashMap-put-get-iterate                     18635.0621+-1417.9121  !  22238.7337+-1387.8773     ! definitely 1.1934x slower
   regexp-prototype-is-not-instance               33.5417+-0.6940     ?     34.0762+-0.1979        ? might be 1.0159x slower
   int-overflow-local                          10229.2027+-1060.2363  ^    784.1418+-21.6014       ^ definitely 13.0451x faster
   build-large-object                          17144.2648+-5343.0765  ^   4126.3073+-73.1249       ^ definitely 4.1549x faster
   in-four-cases                               39300.6547+-2027.3964  ^   9882.2869+-1526.0332     ^ definitely 3.9769x faster
   new-array-push                               1483.6288+-22.3444    ^    702.1580+-68.3994       ^ definitely 2.1130x faster
   switch-char                                  4878.7073+-3467.6638  ^    202.9942+-0.9861        ^ definitely 24.0337x faster
   getter-no-activation                        39519.6603+-2598.6809  ^  25761.0233+-2174.8650     ^ definitely 1.5341x faster
   to-number-only-string                         352.1898+-12.5124    ^    283.8640+-9.0932        ^ definitely 1.2407x faster
   direct-arguments-length                      4688.1620+-466.5394   ^   3171.5772+-598.8741      ^ definitely 1.4782x faster
   infer-constant-property                      1059.0428+-1.4264     !  13908.7482+-3415.6542     ! definitely 13.1333x slower
   regexp-prototype-split-observable-side-effects3-flags
                                                  27.1600+-0.2757     ?     27.4373+-0.1373        ? might be 1.0102x slower
   ArrayBuffer-Int8Array-alloc-long-lived       4439.0140+-111.8431   ^   3673.8723+-81.9244       ^ definitely 1.2083x faster
   ArrayBuffer-Int32Array-byteOffset           40078.1538+-1145.1199  ^  25596.5133+-185.7913      ^ definitely 1.5658x faster
   ArrayBuffer-DataView-alloc-large-long-lived
                                                7594.1257+-194.3760   ^   6807.6210+-288.3406      ^ definitely 1.1155x faster
   regexp-prototype-split-observable-side-effects
                                                  99.9468+-1.3605     ?    100.3839+-0.5029        ?
   put-by-val-with-symbol-slightly-polymorphic
                                                8203.6595+-345.1579   ^   4655.1523+-598.7762      ^ definitely 1.7623x faster
   infer-closure-const-then-mov-no-inline       1978.8660+-178.0688   ^    135.8579+-1.2508        ^ definitely 14.5657x faster
   string-repeat-resolving-no-inline            2365.8768+-55.1826    ^   1138.1760+-11.6861       ^ definitely 2.0787x faster
   string-sub                                   9175.9342+-1050.2348  ^   2463.3589+-462.4275      ^ definitely 3.7250x faster
   Int8Array-load-with-byteLength               8822.6748+-280.0635   ^   3844.3047+-124.3073      ^ definitely 2.2950x faster
   negative-zero-negate                           24.6509+-0.3419     !     36.1852+-0.7239        ! definitely 1.4679x slower
   map-for-each                                 1028.7622+-101.0749   ^    366.9850+-6.0194        ^ definitely 2.8033x faster
   large-int-neg                               10213.9872+-1378.9600  ^    521.7245+-2.1630        ^ definitely 19.5774x faster
   is-symbol-mixed                              1867.1218+-44.6055    !   2371.4758+-226.8461      ! definitely 1.2701x slower
   fold-put-by-id-to-multi-put-by-offset       38080.0532+-3670.9028  ^  15005.2736+-2139.3630     ^ definitely 2.5378x faster
   array-with-double-increment                  1782.6188+-581.6643   ^    215.4310+-4.9877        ^ definitely 8.2747x faster
   adapt-to-double-divide                       1632.9827+-2.5768     ^    350.2128+-6.1977        ^ definitely 4.6628x faster
   get-by-val-with-symbol-self-or-proto        33451.2441+-3864.4443  ^  10598.0786+-1407.0952     ^ definitely 3.1563x faster
   Int16Array-load-int-mul                      1797.4509+-334.1511   ^    116.2917+-2.9121        ^ definitely 15.4564x faster
   ftl-polymorphic-urshift                     61246.4396+-724.1847   ^  24072.5450+-1651.8745     ^ definitely 2.5442x faster
   function-test                                1490.7845+-80.3131    ^    216.6835+-30.3361       ^ definitely 6.8800x faster
   gcse-poly-get                               60699.5983+-7672.6345  ^  35721.8609+-10233.6168    ^ definitely 1.6992x faster
   assign-custom-setter-polymorphic             2129.3787+-208.3106   ?   2242.2291+-254.2552      ? might be 1.0530x slower
   super-getter                               118447.4937+-8414.2272  ^  88182.1843+-2838.8196     ^ definitely 1.3432x faster
   string-repeat-small-not-resolving            2036.7520+-86.7453    ^    297.7766+-8.1166        ^ definitely 6.8399x faster
   get-by-id-quadmorphic-check-structure-elimination-simple
                                                4892.5680+-1144.4163  ^    113.8707+-0.7450        ^ definitely 42.9660x faster
   hoist-poly-check-structure                    634.9145+-13.3529    !   2302.9399+-570.7385      ! definitely 3.6272x slower
   arguments-out-of-bounds                      9128.0778+-2370.9185  ^    444.4434+-4.4832        ^ definitely 20.5382x faster
   string-hash                                  3063.6609+-223.9141   ^   2341.6533+-237.5740      ^ definitely 1.3083x faster
   licm-dragons-overflow                       12020.5272+-15.0055    ^   1097.4153+-2.2262        ^ definitely 10.9535x faster
   double-to-int32                             43565.3240+-4887.9236  ^   6023.5360+-10.9100       ^ definitely 7.2325x faster
   double-to-int32-typed-array-no-inline        1389.0924+-195.6835   ^    191.1787+-3.5339        ^ definitely 7.2659x faster
   array-nonarray-polymorhpic-access            7931.1720+-143.1030   !  24450.4243+-7385.9982     ! definitely 3.0828x slower
   is-function-fold-tricky-internal-function
                                               14470.1478+-485.1141   ^    488.6823+-201.3629      ^ definitely 29.6105x faster
   put-by-id-transition-with-indexing-header
                                                3473.6345+-99.1605    !   9716.7741+-121.5872      ! definitely 2.7973x slower
   scoped-arguments-possibly-overridden-length
                                                4307.4585+-487.8730       3699.5529+-362.1986        might be 1.1643x faster
   is-object-or-null-fold-functions            14022.6146+-728.1217   ^     90.1827+-1.8192        ^ definitely 155.4912x faster
   string-test                                  1172.1592+-84.0541    ^    428.3381+-31.7686       ^ definitely 2.7365x faster
   licm-dragons                                19627.2680+-38.4810    !  59811.0988+-9190.8637     ! definitely 3.0473x slower
   set-for-each                                 1074.4554+-81.9492    ^    359.5098+-44.0073       ^ definitely 2.9887x faster
   simple-regexp-test-folding-fail-with-hoisted-regexp
                                               24100.1926+-1155.3181  ^   9972.1740+-545.8757      ^ definitely 2.4167x faster
   switch-string-basic-var                      9556.6006+-512.0366   ^   1296.6805+-21.3211       ^ definitely 7.3701x faster
   in-two-cases                                22363.2385+-1351.8196  ^   6246.5432+-580.9552      ^ definitely 3.5801x faster
   fround                                       9276.4103+-1226.3594  ^    617.4202+-2.2410        ^ definitely 15.0245x faster
   is-array-for-non-array-object                1050.5146+-135.4409   ^    130.8834+-4.1573        ^ definitely 8.0263x faster
   get-by-id-proto-or-self                     22702.5115+-3137.1193  ^  10988.5007+-2732.4263     ^ definitely 2.0660x faster
   put-by-id-slightly-polymorphic              12597.0798+-2001.8845  ^    179.0613+-11.6202       ^ definitely 70.3506x faster
   regexp-prototype-test-observable-side-effects2
                                                  25.2469+-0.2338     ?     25.5888+-0.3833        ? might be 1.0135x slower
   minus-boolean-double                         1374.2522+-156.9987   ^    107.7012+-0.7894        ^ definitely 12.7599x faster
   direct-call                                 36082.2842+-3749.0112  ^   2506.8192+-2.8421        ^ definitely 14.3937x faster
   plus-boolean                                 5338.2700+-360.6362   ^     77.1555+-1.7984        ^ definitely 69.1885x faster
   asmjs_bool_bug                              24026.1796+-3878.3698  ^    348.7725+-1.6079        ^ definitely 68.8878x faster
   string-var-equality                         22695.9570+-2801.5993  ^   1123.6532+-1.8051        ^ definitely 20.1984x faster
   inline-get-scoped-var                        4441.3214+-1339.8786  ^    151.7833+-1.4997        ^ definitely 29.2609x faster
   try-get-by-id-polymorphic                    5620.4070+-372.4620   ^   2763.5142+-387.9721      ^ definitely 2.0338x faster
   negative-zero-divide                           25.1556+-0.6986     !     38.5757+-0.8412        ! definitely 1.5335x slower
   switch-string-length-tower                   9091.8721+-378.0982   ^   1298.3945+-248.4091      ^ definitely 7.0024x faster
   regexp-prototype-split-observable-side-effects3-unicode
                                                  27.1586+-0.4647     ?     27.6871+-0.5989        ? might be 1.0195x slower
   int-or-other-min-then-get-by-val             4131.3898+-747.8720   ^   1084.8802+-107.9385      ^ definitely 3.8082x faster
   get-by-val-with-string-self-or-proto        32054.5430+-1202.7188  ^  10360.4456+-2653.2376     ^ definitely 3.0939x faster
   string-concat-simple                         8212.5428+-1225.5211  ^    336.9974+-1.3200        ^ definitely 24.3697x faster
   mul-boolean                                  1398.7278+-173.4197   ^     86.4725+-3.8021        ^ definitely 16.1754x faster
   abc-simple-forward-loop                     29938.8403+-19.3019    ^   3299.4292+-5.9097        ^ definitely 9.0739x faster
   raytrace-with-try-catch                      2645.4706+-74.0310    !   3707.7845+-175.1809      ! definitely 1.4016x slower
   cmpeq-obj-to-obj-other                       4615.6990+-275.9153   ^   1051.0870+-42.0752       ^ definitely 4.3914x faster
   Number-isNaN                                27503.4932+-1793.6772  ^   1988.0930+-11.4313       ^ definitely 13.8341x faster
   switch-string-short                         10089.1857+-1410.2364  ^   1221.3969+-2.0778        ^ definitely 8.2604x faster
   ftl-polymorphic-lshift                      56241.3263+-1173.0711  ^  23717.5595+-1383.7415     ^ definitely 2.3713x faster
   strict-osr-entry                            19519.3182+-1973.0100  ^    781.7899+-3.8172        ^ definitely 24.9675x faster
   rest-parameter-construction-performance     15967.9420+-1668.8172  ^   1570.8328+-6.4165        ^ definitely 10.1653x faster
   ftl-polymorphic-StringFromCharCode          29896.5212+-158.4682   ^   7372.1013+-75.2545       ^ definitely 4.0554x faster
   misc-strict-eq                              17622.1627+-3647.2445  ^   1564.1575+-1.8156        ^ definitely 11.2662x faster
   simple-activation-demo                       9109.7997+-60.9396    ^   1073.0653+-1.9852        ^ definitely 8.4895x faster
   varargs-strict-mode                         28506.6061+-246.0553   ^   5860.6100+-677.6152      ^ definitely 4.8641x faster
   getter-prototype                           207539.0890+-8181.3903  ^ 139307.9070+-16546.9777    ^ definitely 1.4898x faster
   double-real-use                             10318.6202+-44.5130    !  51076.1508+-18031.6043    ! definitely 4.9499x slower
   inlined-put-by-val-with-symbol-transition
                                               30709.6035+-454.5329   ^  23368.7979+-1369.1781     ^ definitely 1.3141x faster
   Int16Array-bubble-sort-with-byteLength     161717.5312+-25147.7848 ^  60328.9102+-6020.7938     ^ definitely 2.6806x faster
   string-transcoding                           4994.4735+-158.4777   ^   3855.7568+-108.4869      ^ definitely 1.2953x faster
   branch-fold                                   760.8666+-22.2035    ^    121.4544+-0.7064        ^ definitely 6.2646x faster
   call-or-not-call                           103021.8171+-4545.4857  ^  38452.4869+-5863.7969     ^ definitely 2.6792x faster
   double-to-uint32-typed-array                 1341.8726+-110.5656   ^    199.8752+-8.9116        ^ definitely 6.7136x faster
   emscripten-cube2hash                         7040.7022+-374.7434   ^   2782.4703+-54.1714       ^ definitely 2.5304x faster
   empty-string-plus-int                        2153.6410+-64.7459    ^    917.3268+-34.8147       ^ definitely 2.3477x faster
   ArrayBuffer-Int8Array-alloc                  3251.1931+-159.2160   ^   2654.3103+-39.3823       ^ definitely 1.2249x faster
   min-boolean                                  2507.2358+-472.0666   ^    119.7040+-0.7796        ^ definitely 20.9453x faster
   get-by-val-with-string-bimorphic-check-structure-elimination-simple
                                                3235.6548+-865.9092       2094.5350+-506.4984        might be 1.5448x faster
   is-number-fold                               7963.1315+-739.2448   ^     84.0741+-1.9060        ^ definitely 94.7156x faster
   arguments-strict-mode                       29934.8472+-854.5866   ^  11934.3685+-756.2025      ^ definitely 2.5083x faster
   logical-not                                  2166.7542+-266.1903   ^    433.5729+-8.4445        ^ definitely 4.9974x faster
   ftl-polymorphic-bitxor                      55545.5933+-1147.7797  ^  25128.1819+-1188.7537     ^ definitely 2.2105x faster
   put-by-val-with-string-slightly-polymorphic
                                                7451.5670+-684.9672   ^   5308.6226+-515.2159      ^ definitely 1.4037x faster
   weird-inlining-const-prop                     873.9534+-44.3727    ^    228.9942+-3.5838        ^ definitely 3.8165x faster
   Int16Array-alloc-long-lived                 54770.1669+-1626.9525  ^  17582.9717+-495.7344      ^ definitely 3.1150x faster
   try-get-by-id-basic                          5542.6025+-463.4953   ^   2178.6370+-149.0491      ^ definitely 2.5441x faster
   Float32Array-matrix-mult                     3826.1835+-340.8529   ^   2147.4628+-160.4358      ^ definitely 1.7817x faster
   mod-boolean-double                           2227.3122+-614.1219   ^    235.4590+-0.4708        ^ definitely 9.4594x faster
   eval-not-eval-compute                       12960.3390+-4.3080     ^   1124.2477+-1.7343        ^ definitely 11.5280x faster
   for-of-iterate-array-keys                     958.2460+-55.6979    !   3062.3286+-199.0946      ! definitely 3.1958x slower
   get-by-val-with-symbol-proto-or-self        34157.7545+-2921.3575  ^  10448.9301+-3791.7809     ^ definitely 3.2690x faster
   string-repeat-small-resolving                2038.7000+-91.8130    ^    874.5049+-2.9055        ^ definitely 2.3313x faster
   infer-closure-const-then-reenter-no-inline
                                               44490.2962+-3581.0490  ^   2417.8162+-9.0987        ^ definitely 18.4010x faster
   is-symbol                                     192.1811+-4.1074     ^    160.6390+-7.8257        ^ definitely 1.1964x faster
   fold-get-by-id-to-multi-get-by-offset       18240.2095+-2281.1807  ^   6029.1832+-545.1521      ^ definitely 3.0253x faster
   plus-boolean-arith                           1451.2190+-157.5162   ^     82.6780+-0.3035        ^ definitely 17.5527x faster
   Int8Array-alloc-long-lived                  54053.7256+-2791.3554  ^  16881.1317+-720.0473      ^ definitely 3.2020x faster
   nested-function-parsing                     34317.6875+-986.7736      34045.4105+-1234.7512     
   get-by-val-with-string-check-structure-elimination
                                               32360.1612+-8279.5344     27540.9747+-2836.8066       might be 1.1750x faster
   direct-call-arity-mismatch                  54028.5543+-7432.4150  ^   3200.8661+-6.0006        ^ definitely 16.8794x faster
   abc-skippy-loop                             65709.8962+-20518.4588 ^   1693.3045+-3.8638        ^ definitely 38.8057x faster
   allocate-big-object                          1119.3803+-90.5765    ^    140.2633+-2.3651        ^ definitely 7.9806x faster
   ftl-polymorphic-sub                         57625.9197+-128.1456   ^  24190.5678+-599.2520      ^ definitely 2.3822x faster
   direct-arguments-overridden-length           9465.6661+-531.1064   ^   3592.6080+-352.9394      ^ definitely 2.6348x faster
   switching-size-classes                       7258.9665+-863.6167   ^   2184.6644+-25.8189       ^ definitely 3.3227x faster
   chain-getter-access                         81679.4560+-5881.6013  ^  32211.5356+-2330.4149     ^ definitely 2.5357x faster
   to-number-number-string-number-string         723.5347+-22.2328    ^    579.9693+-17.3221       ^ definitely 1.2475x faster
   string-concat-pair-simple                   12691.7700+-1318.2511  ^    163.4750+-3.1529        ^ definitely 77.6374x faster
   is-undefined-fold-tricky                     9980.0522+-296.3209   ^    119.8411+-1.2010        ^ definitely 83.2774x faster
   get-by-val-with-string-bimorphic-check-structure-elimination
                                               27096.0591+-4136.2050     21958.9110+-3558.7640       might be 1.2339x faster
   substring-concat-weird                      21480.8533+-1305.7842  ^  11316.3711+-398.0340      ^ definitely 1.8982x faster
   get-by-val-with-string-quadmorphic-check-structure-elimination-simple
                                                3381.3585+-452.2135   ^   1886.6633+-576.4156      ^ definitely 1.7922x faster
   string-repeat-resolving                      2387.2336+-39.4399    ^   1140.9602+-13.9154       ^ definitely 2.0923x faster
   exit-length-on-plain-object                  5349.8948+-217.1686   ^   3750.5049+-24.8744       ^ definitely 1.4264x faster
   string-add-constant-folding                 77831.2870+-896.9637   ^  40564.0117+-733.0240      ^ definitely 1.9187x faster
   regexp-set-last-index                       24044.3185+-7238.9859  ^    488.8840+-5.6319        ^ definitely 49.1821x faster
   simple-regexp-test-folding-with-hoisted-regexp
                                               22748.0129+-1064.9285  ^  11696.0681+-2294.9847     ^ definitely 1.9449x faster
   put-by-val-with-symbol-replace-and-transition
                                               26989.1581+-2649.1045  ^   5748.8760+-914.9630      ^ definitely 4.6947x faster
   put-by-val-machine-int                       3233.6431+-66.7929    ^    364.1832+-43.4693       ^ definitely 8.8792x faster
   int-or-other-max-then-get-by-val             4392.1464+-363.2251   ^   1046.4180+-8.5370        ^ definitely 4.1973x faster
   Float64Array-alloc-long-lived               58539.8110+-381.0193   ^  19326.1359+-1245.5874     ^ definitely 3.0290x faster
   slow-ternaries                              79068.3453+-959.1010   ^   1021.8308+-5.1929        ^ definitely 77.3791x faster
   obviously-elidable-new-object               67551.8510+-9038.4563  ^   6330.2921+-25.9559       ^ definitely 10.6712x faster
   external-arguments-getbyval                   415.5874+-52.5744    ^    105.7963+-4.4064        ^ definitely 3.9282x faster
   elidable-new-object-then-call              140156.3033+-18674.1968 ^   8368.9023+-45.4526       ^ definitely 16.7473x faster
   Float64Array-to-Int16Array-set              87481.1305+-1902.7621  ^  51050.8534+-5475.3295     ^ definitely 1.7136x faster
   slow-convergence                              475.6215+-33.2366    !    841.1107+-28.3023       ! definitely 1.7684x slower
   direct-tail-call-inlined-caller             52976.7035+-6856.2337  ^   2842.8353+-3.5138        ^ definitely 18.6352x faster
   object-and                                    731.5130+-0.9200     ^    180.6427+-2.1045        ^ definitely 4.0495x faster
   simple-poly-call                              485.9888+-47.0761    ^     84.5164+-2.0617        ^ definitely 5.7502x faster
   array-prototype-every                       23996.4648+-651.3806   ^   1735.2089+-246.0883      ^ definitely 13.8292x faster
   string-out-of-bounds                         9878.2468+-3601.5611  ^    410.0684+-2.1276        ^ definitely 24.0893x faster
   string-repeat-single-not-resolving            584.0555+-13.9272    ^    452.4161+-5.7140        ^ definitely 1.2910x faster
   substring-concat                            22785.1201+-2412.5567  ^  12647.0440+-884.2259      ^ definitely 1.8016x faster
   fold-put-by-val-with-string-to-multi-put-by-offset
                                               24285.0234+-1228.5280  ^  11055.6669+-1480.4345     ^ definitely 2.1966x faster
   is-object-or-null-trickier-internal-function
                                               15953.6629+-845.6675   ^    479.5978+-152.3953      ^ definitely 33.2647x faster
   in-one-case-true                            21264.8500+-2112.2148  ^   4580.5304+-685.6019      ^ definitely 4.6424x faster
   array-prototype-reduceRight                 22729.6499+-1576.2775  ^   1709.6840+-21.3678       ^ definitely 13.2947x faster
   cfg-simplify                                 3015.6450+-213.2138   ^    126.4125+-0.6923        ^ definitely 23.8556x faster
   string-get-by-val                            2393.4675+-708.2596   ^    125.5305+-2.1296        ^ definitely 19.0668x faster
   infer-one-time-closure-two-vars              7558.3427+-6.1559     ^    374.2617+-4.4068        ^ definitely 20.1953x faster
   try-catch-get-by-val-direct-arguments         990.7247+-94.4711    ^    166.3491+-2.5373        ^ definitely 5.9557x faster
   imul-mixed                                   8238.8497+-1170.5597  ^    458.8457+-2.5644        ^ definitely 17.9556x faster
   object-int-add                               3322.7558+-3.2352     ^    711.5399+-4.8374        ^ definitely 4.6698x faster
   infer-closure-const-then-mov                39155.6927+-1794.3160  ^    559.9096+-3.9229        ^ definitely 69.9322x faster
   string-prototype-split-observable-side-effects3-sticky
                                                  31.0980+-0.3972     ?     31.5852+-0.3554        ? might be 1.0157x slower
   regexp-exec                                 13413.4360+-1126.8373     12979.6868+-776.9066        might be 1.0334x faster
   is-object-or-null-trickier-function         15664.0350+-1260.2904  ^    147.7795+-2.1595        ^ definitely 105.9960x faster
   destructuring-parameters-overridden-by-function
                                                  44.6833+-2.0970     !     56.1740+-1.0062        ! definitely 1.2572x slower
   structure-hoist-over-transitions             1188.5062+-77.9408    ^    166.3240+-1.9417        ^ definitely 7.1457x faster
   getter-richards                           1870861.8069+-91045.7655  1763940.5699+-73996.3859      might be 1.0606x faster
   destructuring-swap                           3467.1960+-378.1930   ^    253.4640+-4.5321        ^ definitely 13.6792x faster
   imul-double-only                             2376.2255+-627.8747   ^    372.5678+-0.6912        ^ definitely 6.3780x faster
   scoped-arguments-overridden-length           9179.8841+-614.1139   ^   3852.3544+-469.4162      ^ definitely 2.3829x faster
   string-prototype-split-observable-side-effects3-unicode
                                                  31.1433+-1.0043     ?     31.3238+-0.4691        ?
   branch-on-string-as-boolean                 54603.4924+-7277.8398  ^  12430.5773+-9.7487        ^ definitely 4.3927x faster
   switch-string-basic                          9689.2013+-538.7360   ^   1216.3824+-21.8450       ^ definitely 7.9656x faster
   strcat-length-const                         19361.3503+-894.0944   ^    273.9448+-2.1595        ^ definitely 70.6761x faster
   abs-boolean                                  2151.6503+-369.6628   ^    946.7410+-395.6456      ^ definitely 2.2727x faster
   global-object-access-with-mutating-structure
                                                1337.1605+-14.8812    ^    675.1790+-6.8945        ^ definitely 1.9805x faster
   method-on-number                             2658.0237+-136.5024       2474.4377+-311.9158        might be 1.0742x faster
   function-dot-apply                           3439.3630+-165.7626   ^   1215.2165+-184.9074      ^ definitely 2.8302x faster
   string-rope-with-object                      7279.6317+-72.5944    ^   1609.0100+-10.5057       ^ definitely 4.5243x faster
   fixed-typed-array-storage                     678.6493+-89.7249    ^     90.6573+-2.5359        ^ definitely 7.4859x faster
   hoist-poly-check-structure-effectful-loop
                                                1316.3505+-20.1843    !  11257.6483+-1228.8698     ! definitely 8.5522x slower
   varargs-construct                           20203.2960+-364.1737   ^   5638.3148+-120.2348      ^ definitely 3.5832x faster
   string-prototype-split-observable-side-effects3-flags
                                                  30.7679+-0.5843     ?     31.4160+-0.3122        ? might be 1.0211x slower
   direct-tail-call-arity-mismatch             52339.2155+-12375.7018 ^   2991.8942+-1.8870        ^ definitely 17.4937x faster
   object-keys-map-values                      17079.5035+-544.4413   ^   7098.5897+-337.4973      ^ definitely 2.4060x faster
   large-map-iteration                        106307.4740+-1940.4542  ^  57859.5916+-2886.2813     ^ definitely 1.8373x faster
   set-for-of                                   1243.4470+-78.7777    !   4467.1772+-270.7544      ! definitely 3.5926x slower
   regexp-nested-nonzero-min-counted-parens       22.8195+-0.4854     ?     23.4977+-2.2519        ? might be 1.0297x slower
   sin-boolean                                  2867.6262+-334.3077   ^    530.9230+-5.1268        ^ definitely 5.4012x faster
   sink-huge-activation                        16316.4987+-1133.6482  ^   2633.0128+-220.1995      ^ definitely 6.1969x faster
   getter-richards-try-catch                  211860.3295+-6944.0964  ^ 166622.6597+-5611.4838     ^ definitely 1.2715x faster
   global-var-const-infer                         83.6815+-5.9599     !     99.5039+-0.8340        ! definitely 1.1891x slower
   int-or-other-add                             4063.4015+-618.1310   ^    364.9211+-11.1542       ^ definitely 11.1350x faster
   string-get-by-val-big-char                   4954.5808+-674.7847   ^    578.3500+-28.5600       ^ definitely 8.5668x faster
   bigswitch-indirect-symbol                  464742.5231+-108432.6261            ERROR             
   function-call                                4623.1557+-126.4052   ^    406.6387+-2.2411        ^ definitely 11.3692x faster
   switch-string-basic-big-var                 10128.8616+-1429.7096  ^   1414.4094+-280.4916      ^ definitely 7.1612x faster
   object-closure-call                          3059.7218+-334.5183   !   4833.6383+-545.3624      ! definitely 1.5798x slower
   varargs-construct-inline                    24406.0865+-880.2446   ^  15712.9268+-1688.4481     ^ definitely 1.5532x faster
   eval-not-eval-compute-args                  12967.3883+-12.3365    ^   1121.9241+-2.1627        ^ definitely 11.5582x faster
   typed-array-get-set-by-val-profiling       476229.1743+-12559.1105 ^ 252582.5486+-19250.9239    ^ definitely 1.8854x faster
   regexp-prototype-split-observable-side-effects3-ignoreCase
                                                  26.9185+-0.4914     ?     27.7415+-0.4981        ? might be 1.0306x slower
   object-urshift                                729.9105+-3.3445     ^    183.1959+-2.4889        ^ definitely 3.9843x faster
   string-concat                               61000.1010+-4205.8187  ^  23430.8745+-3100.6881     ^ definitely 2.6034x faster
   get-by-val-with-symbol-bimorphic-check-structure-elimination
                                               38721.7119+-6056.2569     27919.3978+-7796.7450       might be 1.3869x faster
   max-boolean                                  2487.1429+-200.6277   ^    121.0063+-2.3480        ^ definitely 20.5538x faster
   captured-assignments                           37.5867+-0.9418     !     43.9782+-0.3761        ! definitely 1.1700x slower
   elidable-new-object-tree                   121802.0997+-28530.8977 ! 238383.4127+-12107.4780    ! definitely 1.9571x slower
   int52-spill                                  1657.5552+-37.9277    ^   1052.0446+-28.0977       ^ definitely 1.5756x faster
   eval-compute                                13163.7725+-5.0432     ^   1314.0922+-4.9664        ^ definitely 10.0174x faster
   implicit-bigswitch-indirect-symbol         213807.9379+-42823.8528 ^  15815.3632+-1500.6737     ^ definitely 13.5190x faster
   custom-setter-getter-as-put-get-by-id          64.0121+-2.0133     ?     66.2387+-1.7120        ? might be 1.0348x slower
   undefined-test                               1202.1111+-163.7888   ^    426.4380+-17.1818       ^ definitely 2.8190x faster
   is-function-fold                            12499.4852+-2190.3803  ^     88.1230+-1.2696        ^ definitely 141.8413x faster
   elidable-new-object-dag                    126956.0599+-20695.4520 ^  33804.5842+-8942.5213     ^ definitely 3.7556x faster
   is-object-or-null-tricky-function           15189.1694+-1210.3277  ^    149.4853+-1.9373        ^ definitely 101.6098x faster
   integer-modulo                                316.7169+-32.3551    ^    200.4540+-15.1420       ^ definitely 1.5800x faster
   bigswitch                                    9965.7231+-138.0134              ERROR             
   is-array-for-mixed-case                      2083.4145+-82.5339    ^   1666.4688+-81.0891       ^ definitely 1.2502x faster
   get-by-val-with-string-chain-from-try-block
                                                6995.9724+-830.9222   ^   4187.5875+-614.6983      ^ definitely 1.6706x faster
   put-by-val-with-string                      43270.0693+-1446.1860  ^  14150.7241+-1672.5163     ^ definitely 3.0578x faster
   generator-create                              184.2548+-7.7820     ^     74.6522+-4.2838        ^ definitely 2.4682x faster
   stringalloc                                 98214.5621+-9361.8844  ^   7830.5090+-77.2229       ^ definitely 12.5426x faster
   singleton-scope                             36955.0998+-2629.7133  ^   2413.5200+-3.5087        ^ definitely 15.3117x faster
   freeze-and-do-work                           7346.9056+-6.2169     !  50538.6135+-12534.4073    ! definitely 6.8789x slower
   function-with-eval                          20875.8666+-1147.6838  ^   5259.3795+-205.6818      ^ definitely 3.9693x faster
   bound-function-construction-performance     29009.3275+-1209.7476  ^  25148.6016+-1616.8716     ^ definitely 1.1535x faster
   indexed-properties-in-objects                 653.0013+-2.5478     !   2529.3196+-411.3652      ! definitely 3.8734x slower
   raytrace-with-empty-try-catch                1679.3804+-85.3008    !   3107.1550+-194.1672      ! definitely 1.8502x slower
   put-by-id                                   11987.4171+-640.1614   ?  20887.8169+-17830.8765    ? might be 1.7425x slower
   regexp-prototype-split-observable-side-effects4
                                                  27.6613+-0.2783     !     28.2013+-0.1823        ! definitely 1.0195x slower
   string-prototype-split-observable-side-effects
                                                 113.2936+-1.7560     !    116.6794+-0.5996        ! definitely 1.0299x slower
   setter                                      39617.6245+-1788.5777  !  45360.2520+-3470.1134     ! definitely 1.1450x slower
   int52-back-and-forth                         3213.7493+-472.6648   ^    397.9970+-4.5222        ^ definitely 8.0748x faster
   simple-regexp-test-folding-fail             30378.8456+-1070.4243  ^  15801.0487+-2001.5489     ^ definitely 1.9226x faster
   ftl-library-inlining-dataview               16450.4668+-1970.0118  !  27463.7805+-3640.3145     ! definitely 1.6695x slower
   object-test                                  1289.0577+-108.6059   ^    213.1230+-3.3610        ^ definitely 6.0484x faster
   math-with-out-of-bounds-array-values        11964.8430+-505.9565   ^   3380.5685+-484.2070      ^ definitely 3.5393x faster
   many-foreach-calls                            837.9088+-26.4623    ^    209.8425+-4.0143        ^ definitely 3.9930x faster
   int-or-other-sub-then-get-by-val             4011.0377+-486.9852   ^    763.0765+-220.6635      ^ definitely 5.2564x faster
   fold-get-by-id-to-multi-get-by-offset-rare-int
                                               19996.2499+-2442.4890  ^   6657.5817+-1641.9815     ^ definitely 3.0035x faster
   get_callee_polymorphic                       3401.7440+-71.0516    ^   1444.2465+-72.6894       ^ definitely 2.3554x faster
   switch-char-constant                         3552.3680+-856.5640   ^    100.2561+-0.4294        ^ definitely 35.4329x faster
   string-prototype-search-observable-side-effects4
                                                  28.9081+-0.3301     !     29.4725+-0.2220        ! definitely 1.0195x slower
   get-by-id-bimorphic-check-structure-elimination-simple
                                                4254.1116+-173.5034   ^     94.5690+-2.1456        ^ definitely 44.9842x faster
   destructuring-arguments                    110949.6752+-4792.4001  ^  24035.3739+-1945.8803     ^ definitely 4.6161x faster
   object-int-sub                               3301.4413+-2.2214     ^    712.1133+-3.9057        ^ definitely 4.6361x faster
   map-constant-key                           432833.8854+-12857.0594 ^ 350720.3276+-57078.4442    ^ definitely 1.2341x faster
   abc-simple-backward-loop                    28330.2605+-18.7685    ^   3148.4747+-7.0634        ^ definitely 8.9981x faster
   sorting-benchmark                            4441.5121+-239.9759   ^   2105.4113+-11.9420       ^ definitely 2.1096x faster
   int-or-other-div-then-get-by-val             2757.3698+-291.1301   ^    874.2120+-64.3134       ^ definitely 3.1541x faster
   is-string-fold-tricky                       10644.7162+-1411.1875  ^    136.8220+-3.6590        ^ definitely 77.7997x faster
   minus-boolean                                1542.6532+-686.4760   ^     76.3915+-1.6300        ^ definitely 20.1940x faster
   direct-construct                           100425.5349+-4748.7113  ^  29988.5317+-4447.6360     ^ definitely 3.3488x faster
   sinkable-new-object-dag                    174847.4247+-39683.1245 ^  54094.9462+-10380.1073    ^ definitely 3.2322x faster
   Int16Array-to-Int32Array-set                83822.2130+-2800.3488  ^  46190.9311+-2877.7669     ^ definitely 1.8147x faster
   no-inline-constructor                       62642.9573+-6608.5770  !  92454.9135+-8147.4980     ! definitely 1.4759x slower
   spread-large-array                          21844.3773+-55.8965    !  22988.7524+-93.2584       ! definitely 1.0524x slower
   richards-try-catch                         189265.7422+-9136.7501  ! 409983.1932+-35508.8623    ! definitely 2.1662x slower
   HashMap-string-put-get-iterate              18989.7304+-590.3516   ?  19479.1693+-721.4436      ? might be 1.0258x slower
   int-or-other-abs-zero-then-get-by-val        9953.2641+-496.7777   ^   1811.2841+-248.4241      ^ definitely 5.4951x faster
   large-int                                    9394.8367+-659.8549   ^    466.6413+-2.6727        ^ definitely 20.1329x faster
   is-object-or-null-fold-less-tricky          13706.4214+-1497.1451  ^    144.3082+-3.0824        ^ definitely 94.9802x faster
   bug-153431                                    945.8102+-8.3044     ^    526.5346+-18.2674       ^ definitely 1.7963x faster
   plus-boolean-double                          4978.3723+-971.3978   ^    109.9439+-2.8343        ^ definitely 45.2810x faster
   string-get-by-val-out-of-bounds             10068.5779+-444.4304   ^    238.9030+-2.4622        ^ definitely 42.1451x faster
   poly-chain-access-simpler                    2216.0108+-287.7581   ?   2675.1972+-1058.7438     ? might be 1.2072x slower
   regexp-prototype-split-observable-side-effects2
                                                  26.1070+-0.3476     !     27.1075+-0.4707        ! definitely 1.0383x slower
   eval-code-ftl                               69439.3517+-8565.0842  ^   4158.6750+-193.9490      ^ definitely 16.6975x faster
   logical-not-weird-types                       984.8135+-84.6476    ^    163.1597+-2.8441        ^ definitely 6.0359x faster
   big-int-mul                                  5932.7983+-955.2635   ^   4251.1410+-631.7138      ^ definitely 1.3956x faster
   seal-and-do-work                             7344.9880+-5.7550     !  45756.0543+-9147.1465     ! definitely 6.2296x slower
   poly-chain-access-different-prototypes       2128.2138+-229.4370   ?   2417.7523+-282.8837      ? might be 1.1360x slower
   fixed-typed-array-storage-var-index           919.1330+-88.6975    ^    301.0276+-32.1860       ^ definitely 3.0533x faster
   get-by-val-with-symbol-chain-from-try-block
                                                6687.8992+-812.2259   ^   3866.9695+-486.6677      ^ definitely 1.7295x faster
   simple-regexp-test-folding                  29156.6370+-893.7756   ^  17071.4270+-1612.1302     ^ definitely 1.7079x faster
   symbol-tostringtag                            781.1852+-58.9682    !   2305.6280+-182.6219      ! definitely 2.9514x slower
   ArrayBuffer-DataView-alloc-long-lived        4197.0457+-66.7479    ^   3782.5798+-102.4284      ^ definitely 1.1096x faster
   string-concat-long-convert                 304806.3461+-7704.6540  ^  26412.8302+-1049.4999     ^ definitely 11.5401x faster
   map-key-well-typed                          37542.4805+-1787.8934  ?  38089.6295+-26073.8671    ? might be 1.0146x slower
   bigswitch-indirect                          40975.9078+-151.7591              ERROR             
   call-using-spread                           18635.2331+-629.5086   ^   8118.5936+-142.6003      ^ definitely 2.2954x faster
   try-catch-get-by-val-scoped-arguments        2006.4053+-128.1801   ^    552.9700+-82.5428       ^ definitely 3.6284x faster
   has-own-property-name-cache                 90060.7537+-3710.2022  ^  35239.9120+-3357.2731     ^ definitely 2.5556x faster
   varargs                                     15767.2254+-943.2231   ^   5964.2515+-1531.9964     ^ definitely 2.6436x faster
   hard-overflow-check-equal                   28583.1810+-498.7163   ! 107940.4731+-18224.7326    ! definitely 3.7764x slower
   get-by-id-bimorphic-check-structure-elimination
                                               41302.3475+-4875.4674  ^    257.1628+-22.7250       ^ definitely 160.6078x faster
   hoist-make-rope                             36341.0405+-3517.2694  ^   2781.6368+-7.6978        ^ definitely 13.0646x faster
   double-pollution-putbyoffset                 1112.3043+-80.3673    ^    689.6302+-45.5208       ^ definitely 1.6129x faster
   string-prototype-search-observable-side-effects2
                                                  30.1070+-2.3338           29.6689+-0.6035          might be 1.0148x faster
   direct-tail-call-inlined-caller-arity-mismatch
                                               72083.4208+-4674.7616  ^   3370.6248+-0.9216        ^ definitely 21.3858x faster
   put-by-val-direct                              30.0725+-0.4204     ?     30.0967+-0.0758        ?
   get-by-val-with-symbol-check-structure-elimination
                                               47879.7845+-4365.7051  ^  25281.5270+-7878.4608     ^ definitely 1.8939x faster
   math-trunc                                   2460.4899+-95.3389    ^    864.3951+-34.2748       ^ definitely 2.8465x faster
   simple-poly-call-nested                      5472.8477+-876.0875   ^    250.9455+-2.9003        ^ definitely 21.8089x faster
   object-int-add-array                         5095.1188+-2.1307     ^    729.4957+-2.8626        ^ definitely 6.9844x faster
   tear-off-arguments-simple                    1751.5324+-130.0012   ^    228.2027+-7.9458        ^ definitely 7.6753x faster
   string-long-ident-equality                  19417.0393+-1339.5591  ^    563.5150+-2.8233        ^ definitely 34.4570x faster
   switch-constant                              7582.8546+-865.0907   ^    545.1234+-4.1864        ^ definitely 13.9103x faster
   string-replace-generic                      36740.2395+-1734.6423  ^  28714.4478+-751.4002      ^ definitely 1.2795x faster
   double-to-int32-typed-array                  1344.5705+-161.8193   ^    189.7474+-4.7912        ^ definitely 7.0861x faster
   aliased-arguments-getbyval                    358.4050+-33.6769    ^     89.6608+-1.8022        ^ definitely 3.9973x faster
   object-get-own-property-symbols-on-large-array
                                                  71.5048+-2.8285     ?     75.6950+-2.5369        ? might be 1.0586x slower
   Int32Array-alloc-long-lived                 57848.4094+-3950.3486  ^  17471.1480+-1157.9139     ^ definitely 3.3111x faster
   regexp-prototype-test-observable-side-effects
                                                  48.4490+-0.7773     ?     49.3466+-0.8591        ? might be 1.0185x slower
   concat-append-one                            3639.5424+-79.9880    ^   2243.3213+-166.9371      ^ definitely 1.6224x faster
   is-number-fold-tricky                        9521.6561+-774.6776   ^    132.2693+-3.0709        ^ definitely 71.9869x faster
   is-object-or-null-fold                      12654.0102+-561.4116   ^     89.2847+-2.7314        ^ definitely 141.7265x faster
   richards-empty-try-catch                    73254.7674+-3609.8316  ! 266860.3582+-25861.8018    ! definitely 3.6429x slower
   load-varargs-elimination                    56234.9791+-4025.4987  ^   9825.1688+-573.6732      ^ definitely 5.7236x faster
   array-with-int32-add-sub                     1896.2067+-4.5869     ^    304.8503+-4.5437        ^ definitely 6.2201x faster
   string-prototype-split-observable-side-effects3-ignoreCase
                                                  30.8112+-0.5250     ?     31.8985+-2.0898        ? might be 1.0353x slower
   is-array-for-array                           1154.1240+-42.2991    ^    139.8151+-3.5887        ^ definitely 8.2546x faster
   proto-getter-access                         80711.1575+-5188.9749  ^  32895.5217+-1076.5980     ^ definitely 2.4536x faster
   arrowfunction-call-in-function              12221.9800+-860.5302   ^    629.5642+-7.3897        ^ definitely 19.4134x faster
   make-indexed-storage                          406.1863+-5.6612     !   1110.2750+-349.9527      ! definitely 2.7334x slower
   arrowfunction-call-in-class-method          10086.9814+-146.2952   ^   4104.1418+-160.0023      ^ definitely 2.4578x faster
   abc-postfix-backward-loop                   67388.1777+-5085.9865  ^   3149.5381+-7.1339        ^ definitely 21.3962x faster
   string-prototype-split-observable-side-effects2
                                                  30.2032+-0.4205     ?     30.6989+-0.3554        ? might be 1.0164x slower
   elidable-new-object-roflcopter              41046.2181+-4346.2365  ! 120641.8192+-20915.3153    ! definitely 2.9392x slower
   slow-array-profile-convergence                773.0365+-17.0255    !   1439.9473+-167.5414      ! definitely 1.8627x slower
   integer-divide                               8655.6313+-1042.8914      8068.7308+-764.7979        might be 1.0727x faster
   fold-multi-get-by-offset-to-poly-get-by-offset
                                               17545.6720+-1079.5908  ^   6637.3603+-1396.5628     ^ definitely 2.6435x faster
   create-lots-of-functions                    11227.9171+-462.9473   ^    542.9363+-2.5520        ^ definitely 20.6800x faster
   rest-parameter-allocation-elimination      130382.2046+-2636.5520  ^  76937.1348+-1530.1924     ^ definitely 1.6947x faster
   switch-string-big-length-tower-var           9581.9645+-436.3297   ^   1288.0265+-5.0112        ^ definitely 7.4393x faster
   simple-regexp-exec-folding-fail             17064.4095+-10945.6677    11210.5048+-287.7842        might be 1.5222x faster
   lots-of-fields                               1571.7602+-45.9999    ^   1139.4478+-45.2179       ^ definitely 1.3794x faster
   polymorphic-array-call                        255.3065+-12.8429    ^    145.6385+-6.6944        ^ definitely 1.7530x faster
   ftl-polymorphic-rshift                      55689.9571+-1059.5596  ^  24730.3990+-666.4072      ^ definitely 2.2519x faster
   get-by-id-check-structure-elimination        2105.6099+-2.7971     ^    217.5187+-16.5606       ^ definitely 9.6801x faster
   switch-string-length-tower-var               9560.9775+-1548.4552  ^   1252.6923+-4.4267        ^ definitely 7.6323x faster
   string-cons-repeat                           9398.3430+-354.8484   ^    295.6470+-5.0688        ^ definitely 31.7891x faster
   deltablue-for-of                            37286.9476+-2117.5290  !  55890.2270+-4244.0528     ! definitely 1.4989x slower
   is-boolean-fold                              7683.3394+-1730.6588  ^     84.8002+-1.0601        ^ definitely 90.6052x faster
   infer-constant-global-property               9017.9396+-516.4088   ^   6348.2490+-214.8286      ^ definitely 1.4205x faster
   eval-code-ftl-reentry                       76406.0869+-5943.3979  ^   3472.8477+-28.8939       ^ definitely 22.0010x faster

   <geometric>                                  5985.6152+-29.1777               ERROR             

                                                      baseline                  changes                                      
SixSpeed:
   template_string.es5                       1963000.6927+-188712.3538 ^ 845165.1917+-67568.5499    ^ definitely 2.3226x faster
   template_string.es6                       2503595.1678+-236063.8308 ^ 250701.4327+-2148.8667     ^ definitely 9.9864x faster
   defaults.es5                              1834382.5383+-221219.0438 ^  51092.3171+-4.1822        ^ definitely 35.9033x faster
   defaults.es6                               944038.7978+-221707.5660 ^  19756.1526+-5.9209        ^ definitely 47.7845x faster
   map-set-lookup.es5                          47440.8846+-304.9825   ^   4454.4364+-261.8816      ^ definitely 10.6503x faster
   map-set-lookup.es6                           2025.9441+-309.9627   ?   2114.7864+-352.1221      ? might be 1.0439x slower
   spread.es5                                   4727.6503+-360.4586   !   6889.8679+-366.6595      ! definitely 1.4574x slower
   spread.es6                                  23542.0690+-485.3396   ^   7230.1100+-407.3180      ^ definitely 3.2561x faster
   object-assign.es5                           80123.9305+-4287.6655  ^  59408.6879+-2768.1524     ^ definitely 1.3487x faster
   object-assign.es6                           46531.8090+-3895.0678  ^  34593.3359+-1406.3117     ^ definitely 1.3451x faster
   spread-literal.es5                          23162.6502+-509.3735   ^  16292.5839+-772.5043      ^ definitely 1.4217x faster
   spread-literal.es6                          22263.4815+-1535.5261  ^  10104.7893+-817.3117      ^ definitely 2.2033x faster
   map-set.es5                                 26289.7565+-2818.5806  ^  12388.7665+-963.8699      ^ definitely 2.1221x faster
   map-set.es6                                 24782.0852+-2428.0340  !  46691.7753+-4767.2516     ! definitely 1.8841x slower
   destructuring-simple.es5                    50314.5638+-14758.0657 ^   3169.7015+-1.2757        ^ definitely 15.8736x faster
   destructuring-simple.es6                    43765.8735+-3678.6791  ^   3172.9421+-6.5504        ^ definitely 13.7935x faster
   super.es5                                   55638.9348+-4146.8352  ! 130752.0671+-9501.5834     ! definitely 2.3500x slower
   super.es6                                  246717.7593+-3274.3138  ^ 133376.5762+-12602.0265    ^ definitely 1.8498x faster
   for-of-object.es5                           67067.1143+-5476.7252  ^  17638.2940+-1446.9518     ^ definitely 3.8024x faster
   for-of-object.es6                          166958.8336+-2733.9948  ^  98936.9672+-4749.4961     ^ definitely 1.6875x faster
   rest.es5                                    15519.4133+-738.6638   ^   3636.7150+-413.3863      ^ definitely 4.2674x faster
   rest.es6                                    19174.0041+-1108.0920  ^   5891.1603+-711.3924      ^ definitely 3.2547x faster
   regex-u.es5                                 67503.8334+-2591.0645  ^  34998.4650+-3220.7464     ^ definitely 1.9288x faster
   regex-u.es6                                 72763.4528+-5424.0633  ^  52745.3371+-4670.7620     ^ definitely 1.3795x faster
   arrow.es5                                   66038.7709+-10076.8087 ^   3437.9180+-3.4676        ^ definitely 19.2089x faster
   arrow.es6                                   78695.6982+-9668.4675  ^   3437.0383+-5.4865        ^ definitely 22.8964x faster
   bindings-compound.es5                       41739.3317+-7076.5239  ^   2885.3867+-3.8684        ^ definitely 14.4658x faster
   bindings-compound.es6                       47974.5375+-5983.9035  ^   2885.6212+-3.6268        ^ definitely 16.6254x faster
   classes.es5                                 94044.4490+-7121.3494  ^   2759.0291+-22.4916       ^ definitely 34.0861x faster
   classes.es6                                 90909.2358+-6239.8194  ^   2770.6331+-21.1253       ^ definitely 32.8117x faster
   template_string_tag.es5                     90891.1785+-5156.9532  ^   4467.5911+-104.5128      ^ definitely 20.3446x faster
   template_string_tag.es6                    102703.7363+-7234.4405  ^  24558.8040+-3324.2195     ^ definitely 4.1820x faster
   map-string.es5                              84842.1309+-12991.1563 ^   5326.5642+-3.3195        ^ definitely 15.9281x faster
   map-string.es6                             210922.7953+-19322.0576 ^ 142111.1598+-18338.6350    ^ definitely 1.4842x faster
   arrow-declare.es5                          253014.9522+-26767.9605 ^   8700.3505+-73.8535       ^ definitely 29.0810x faster
   arrow-declare.es6                          433975.0735+-52464.6429 ^  12435.6190+-49.4841       ^ definitely 34.8977x faster
   spread-generator.es5                        93791.6126+-4287.6254  ^  25222.1190+-1794.0913     ^ definitely 3.7186x faster
   spread-generator.es6                       176004.8392+-2776.8334  ! 287484.8024+-20291.4775    ! definitely 1.6334x slower
   object-literal-ext.es5                      67046.0371+-619.3928   ^    956.3584+-4.6929        ^ definitely 70.1056x faster
   object-literal-ext.es6                      97095.6206+-1700.9608  ^  46696.5997+-1577.7386     ^ definitely 2.0793x faster
   generator.es5                              159800.3380+-8034.1613  ^  15785.4352+-1280.7970     ^ definitely 10.1233x faster
   generator.es6                              258855.2778+-16008.3460 ! 492831.7225+-44921.8480    ! definitely 1.9039x slower
   arrow-args.es5                             118934.2817+-19771.9509 ^   3754.0338+-2.1607        ^ definitely 31.6817x faster
   arrow-args.es6                             127408.0382+-6366.9417  ^   3753.7575+-1.4545        ^ definitely 33.9415x faster
   for-of-array.es5                           158994.9015+-4476.1990  ^  15112.3440+-422.7017      ^ definitely 10.5209x faster
   for-of-array.es6                           690434.4266+-44799.3520 ^ 137422.7101+-16674.5692    ^ definitely 5.0242x faster
   bindings.es5                                36979.3644+-6555.1973  ^   2883.6365+-1.3519        ^ definitely 12.8239x faster
   bindings.es6                                36772.9650+-5345.3267  ^   2883.1356+-2.0374        ^ definitely 12.7545x faster
   destructuring.es5                           59158.9216+-3724.9030  ^   3968.1195+-1.5368        ^ definitely 14.9086x faster
   destructuring.es6                         1566373.1168+-41556.8211 ^ 462594.5695+-18386.4752    ^ definitely 3.3861x faster
   map-set-object.es5                          65925.2554+-3384.1015  ^  28790.5703+-3385.2015     ^ definitely 2.2898x faster
   map-set-object.es6                          25569.8527+-2110.1741  !  45198.5508+-2144.4086     ! definitely 1.7677x slower

   <geometric>                                 88049.9599+-1798.4501  ^  16534.6536+-110.7921      ^ definitely 5.3252x faster

                                                      baseline                  changes                                      
Geomean of preferred means:
   <scaled-result>                             23283.6320+-61.5727               ERROR             



More information about the webkit-dev mailing list