Changeset 237972 in webkit for trunk/Source/JavaScriptCore/bytecode/ArithProfile.h

Timestamp:

Nov 7, 2018, 5:47:27 PM (7 years ago)

Author:

Caio Lima

Message:

[BigInt] Add support to BigInt into ValueAdd
​https://bugs.webkit.org/show_bug.cgi?id=186177

Reviewed by Keith Miller.

JSTests:

• stress/big-int-negate-jit.js:
• stress/value-add-big-int-and-string.js: Added.
• stress/value-add-big-int-prediction-propagation.js: Added.
• stress/value-add-big-int-untyped.js: Added.

PerformanceTests:

The idea of BigIntBench is to provide a set of microbenchmarks and
benchmarks to evaluate how fast BigInt computations are happening on
JSC implementation.

Now, we are adding microbenchmarks in this set,
but the plan is to move these tests to "JSTest/microbenchmarks" when
BigInt is enabled by default. After that, the focus of Bigint bench is
to provide a set of tests that represents real use cases of BigInt in
JS programs.

• BigIntBench/big-int-add-prediction-propagation.js: Added.
• BigIntBench/big-int-simple-add.js: Added.
• BigIntBench/big-int-simple-sub.js: Added.

Source/JavaScriptCore:

We are adding a very primitive specialization case of BigInts into ValueAdd.
When compiling a speculated version of this node to BigInt, we are currently
calling 'operationAddBigInt', a function that expects only BigInts as
parameter and effectly add numbers using JSBigInt::add. To properly
speculate BigInt operands, we changed ArithProfile to observe when
its result is a BigInt. With this new observation, we are able to identify
when ValueAdd results into a String or BigInt.

Here are some numbers for this specialization running
microbenchmarks:

big-int-simple-add 21.5411+-1.1096 ^{15.3502+-0.7027} definitely 1.4033x faster
big-int-add-prediction-propagation 13.7762+-0.5578 ^{10.8117+-0.5330} definitely 1.2742x faster

• bytecode/ArithProfile.cpp:

(JSC::ArithProfile::emitObserveResult):
(JSC::ArithProfile::shouldEmitSetNonNumeric const):
(JSC::ArithProfile::shouldEmitSetBigInt const):
(JSC::ArithProfile::emitSetNonNumeric const):
(JSC::ArithProfile::emitSetBigInt const):
(WTF::printInternal):
(JSC::ArithProfile::shouldEmitSetNonNumber const): Deleted.
(JSC::ArithProfile::emitSetNonNumber const): Deleted.

• bytecode/ArithProfile.h:

(JSC::ArithProfile::observedUnaryInt):
(JSC::ArithProfile::observedUnaryNumber):
(JSC::ArithProfile::observedBinaryIntInt):
(JSC::ArithProfile::observedBinaryNumberInt):
(JSC::ArithProfile::observedBinaryIntNumber):
(JSC::ArithProfile::observedBinaryNumberNumber):
(JSC::ArithProfile::didObserveNonInt32 const):
(JSC::ArithProfile::didObserveNonNumeric const):
(JSC::ArithProfile::didObserveBigInt const):
(JSC::ArithProfile::setObservedNonNumeric):
(JSC::ArithProfile::setObservedBigInt):
(JSC::ArithProfile::observeResult):
(JSC::ArithProfile::didObserveNonNumber const): Deleted.
(JSC::ArithProfile::setObservedNonNumber): Deleted.

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::makeSafe):

• dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):

• dfg/DFGNode.h:

(JSC::DFG::Node::mayHaveNonNumericResult):
(JSC::DFG::Node::mayHaveBigIntResult):
(JSC::DFG::Node::mayHaveNonNumberResult): Deleted.

• dfg/DFGNodeFlags.cpp:

(JSC::DFG::dumpNodeFlags):

• dfg/DFGNodeFlags.h:
• dfg/DFGOperations.cpp:
• dfg/DFGOperations.h:
• dfg/DFGPredictionPropagationPhase.cpp:
• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileValueAdd):

• ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileValueAdd):

• runtime/CommonSlowPaths.cpp:

(JSC::updateArithProfileForUnaryArithOp):
(JSC::updateArithProfileForBinaryArithOp):

Tools:

• Scripts/run-jsc-benchmarks:

File:

• trunk/Source/JavaScriptCore/bytecode/ArithProfile.h (modified) (13 diffs)

trunk/Source/JavaScriptCore/bytecode/ArithProfile.h

@@ -69 +69 @@
 struct ArithProfile {
 private:
-    static constexpr uint32_t numberOfFlagBits = 5;
+    static constexpr uint32_t numberOfFlagBits = 6;
     static constexpr uint32_t rhsResultTypeShift = numberOfFlagBits;
     static constexpr uint32_t lhsResultTypeShift = rhsResultTypeShift + ResultType::numBitsNeeded;
@@ -122 +122 @@
         constexpr ObservedType observedInt32 { ObservedType().withInt32() };
         constexpr uint32_t bits = observedInt32.bits() << lhsObservedTypeShift;
-        static_assert(bits == 0x400000, "");
+        static_assert(bits == 0x800000, "");
         return fromInt(bits);
     }
@@ -129 +129 @@
         constexpr ObservedType observedNumber { ObservedType().withNumber() };
         constexpr uint32_t bits = observedNumber.bits() << lhsObservedTypeShift;
-        static_assert(bits == 0x800000, "");
+        static_assert(bits == 0x1000000, "");
         return fromInt(bits);
     }
@@ -136 +136 @@
         constexpr ObservedType observedInt32 { ObservedType().withInt32() };
         constexpr uint32_t bits = (observedInt32.bits() << lhsObservedTypeShift) | (observedInt32.bits() << rhsObservedTypeShift);
-        static_assert(bits == 0x480000, "");
+        static_assert(bits == 0x900000, "");
         return fromInt(bits);
     }
@@ -144 +144 @@
         constexpr ObservedType observedInt32 { ObservedType().withInt32() };
         constexpr uint32_t bits = (observedNumber.bits() << lhsObservedTypeShift) | (observedInt32.bits() << rhsObservedTypeShift);
-        static_assert(bits == 0x880000, "");
+        static_assert(bits == 0x1100000, "");
         return fromInt(bits);
     }
@@ -152 +152 @@
         constexpr ObservedType observedInt32 { ObservedType().withInt32() };
         constexpr uint32_t bits = (observedInt32.bits() << lhsObservedTypeShift) | (observedNumber.bits() << rhsObservedTypeShift);
-        static_assert(bits == 0x500000, "");
+        static_assert(bits == 0xa00000, "");
         return fromInt(bits);
     }
@@ -159 +159 @@
         constexpr ObservedType observedNumber { ObservedType().withNumber() };
         constexpr uint32_t bits = (observedNumber.bits() << lhsObservedTypeShift) | (observedNumber.bits() << rhsObservedTypeShift);
-        static_assert(bits == 0x900000, "");
+        static_assert(bits == 0x1200000, "");
         return fromInt(bits);
     }
@@ -166 +166 @@
         NonNegZeroDouble = 1 << 0,
         NegZeroDouble    = 1 << 1,
-        NonNumber        = 1 << 2,
+        NonNumeric       = 1 << 2,
         Int32Overflow    = 1 << 3,
         Int52Overflow    = 1 << 4,
+        BigInt           = 1 << 5,
     };
 
@@ -196 +197 @@
     bool tookSpecialFastPath() const { return m_bits & specialFastPathBit; }
 
-    bool didObserveNonInt32() const { return hasBits(NonNegZeroDouble | NegZeroDouble | NonNumber); }
+    bool didObserveNonInt32() const { return hasBits(NonNegZeroDouble | NegZeroDouble | NonNumeric | BigInt); }
     bool didObserveDouble() const { return hasBits(NonNegZeroDouble | NegZeroDouble); }
     bool didObserveNonNegZeroDouble() const { return hasBits(NonNegZeroDouble); }
     bool didObserveNegZeroDouble() const { return hasBits(NegZeroDouble); }
-    bool didObserveNonNumber() const { return hasBits(NonNumber); }
+    bool didObserveNonNumeric() const { return hasBits(NonNumeric); }
+    bool didObserveBigInt() const { return hasBits(BigInt); }
     bool didObserveInt32Overflow() const { return hasBits(Int32Overflow); }
     bool didObserveInt52Overflow() const { return hasBits(Int52Overflow); }
@@ -206 +208 @@
     void setObservedNonNegZeroDouble() { setBit(NonNegZeroDouble); }
     void setObservedNegZeroDouble() { setBit(NegZeroDouble); }
-    void setObservedNonNumber() { setBit(NonNumber); }
+    void setObservedNonNumeric() { setBit(NonNumeric); }
+    void setObservedBigInt() { setBit(BigInt); }
     void setObservedInt32Overflow() { setBit(Int32Overflow); }
     void setObservedInt52Overflow() { setBit(Int52Overflow); }
@@ -220 +223 @@
             return;
         }
-        m_bits |= NonNumber;
+        if (value && value.isBigInt()) {
+            m_bits |= BigInt;
+            return;
+        }
+        m_bits |= NonNumeric;
     }
 
@@ -262 +269 @@
 #if ENABLE(JIT)    
     // Sets (Int32Overflow | Int52Overflow | NonNegZeroDouble | NegZeroDouble) if it sees a
-    // double. Sets NonNumber if it sees a non-number.
+    // double. Sets NonNumeric if it sees a non-numeric.
     void emitObserveResult(CCallHelpers&, JSValueRegs, TagRegistersMode = HaveTagRegisters);
     
@@ -270 +277 @@
     
     // Sets NonNumber.
-    void emitSetNonNumber(CCallHelpers&) const;
-    bool shouldEmitSetNonNumber() const;
+    void emitSetNonNumeric(CCallHelpers&) const;
+    bool shouldEmitSetNonNumeric() const;
+
+    // Sets BigInt
+    void emitSetBigInt(CCallHelpers&) const;
+    bool shouldEmitSetBigInt() const;
 #endif // ENABLE(JIT)