1. 11 Apr, 2019 1 commit
  2. 04 Mar, 2019 1 commit
  3. 27 Oct, 2017 1 commit
    • Benedikt Meurer's avatar
      [turbofan] Introduce SameValue operator. · c78a98bb
      Benedikt Meurer authored
      We now represent the SameValue operation explicitly in TurboFan and the
      operation can thus participate in all kinds of optimizations. Especially
      we get rid of the JSCall node in the general case, which blocks several
      optimizations across the call. The general, baseline performance is now
      always on par with StrictEqual.
      
      Once the StrictEqual operator is also a simplified operator, we should
      start unifying the type based optimizations in SimplifiedLowering.
      
      In the micro-benchmark we go from
      
        testStrictEqual: 1422 ms.
        testObjectIs: 1520 ms.
        testManualSameValue: 1759 ms.
      
      to
      
        testStrictEqual: 1426 ms.
        testObjectIs: 1357 ms.
        testManualSameValue: 1766 ms.
      
      which gives the expected result.
      
      Bug: v8:7007
      Change-Id: I0de3ff6ff6209ab4c3edb69de6a16e387295a9c8
      Reviewed-on: https://chromium-review.googlesource.com/741228Reviewed-by: 's avatarJaroslav Sevcik <jarin@chromium.org>
      Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#48994}
      c78a98bb
  4. 04 Oct, 2017 1 commit
    • Benedikt Meurer's avatar
      [es2015] Optimize Object.is baseline and interesting cases. · d4da17c6
      Benedikt Meurer authored
      The Object.is builtin provides an entry point to the abstract operation
      SameValue, which properly distinguishes -0 and 0, and also identifies
      NaNs. Most of the time you don't need these, but rather just regular
      strict equality, but when you do, Object.is(o, -0) is the most readable
      way to check for minus zero.
      
      This is for example used in Node.js by formatNumber to properly print -0
      for negative zero. However since the builtin thus far implemented as C++
      builtin and TurboFan didn't know anything about it, Node.js considering
      to go with a more performant, less readable version (which also makes
      assumptions about the input value) in
      
        https://github.com/nodejs/node/pull/15726
      
      until the performance of Object.is will be on par (so hopefully we can
      go back to Object.is in Node 9).
      
      This CL ports the baseline implementation of Object.is to CSA, which
      is pretty straight-forward since SameValue is already available in
      CodeStubAssembler, and inlines a few interesting cases into TurboFan,
      i.e. comparing same SSA node, and checking for -0 and NaN explicitly.
      
      On the micro-benchmarks we go from
      
        testNumberIsMinusZero: 1000 ms.
        testObjectIsMinusZero: 929 ms.
        testObjectIsNaN: 954 ms.
        testObjectIsSame: 793 ms.
        testStrictEqualSame: 104 ms.
      
      to
      
        testNumberIsMinusZero: 89 ms.
        testObjectIsMinusZero: 88 ms.
        testObjectIsNaN: 88 ms.
        testObjectIsSame: 86 ms.
        testStrictEqualSame: 105 ms.
      
      which is a nice 10x to 11x improvement and brings Object.is on par with
      strict equality for most cases.
      
      Drive-by-fix: Also refactor and optimize the SameValue check in the
      CodeStubAssembler to avoid code bloat (by not inlining StrictEqual
      into every user of SameValue, and also avoiding useless checks).
      
      Bug: v8:6882
      Change-Id: Ibffd8c36511f219fcce0d89ed4e1073f5d6c6344
      Reviewed-on: https://chromium-review.googlesource.com/700254Reviewed-by: 's avatarJaroslav Sevcik <jarin@chromium.org>
      Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
      Cr-Commit-Position: refs/heads/master@{#48275}
      d4da17c6