Changeset 199866 in webkit for trunk/Source/JavaScriptCore/runtime/MathCommon.h

Timestamp:

Apr 21, 2016, 9:46:53 PM (9 years ago)

Author:

[email protected]

Message:

[JSC] Commute FDiv-by-constant into FMul-by-reciprocal when it is safe
​https://bugs.webkit.org/show_bug.cgi?id=156871

Patch by Benjamin Poulain <​[email protected]> on 2016-04-21
Reviewed by Filip Pizlo.

FMul is significantly faster than FDiv.
For example, on Haswell, FMul has a latency of 5, a throughput of 1
while FDiv has latency 10-24, throughput 8-18.

Fortunately for us, Sunspider and Kraken have plenty of division
by a simple power of 2 constant. Those are just exponent operations
and can be easily reversed to use FMul instead of FDiv.

LLVM does something similar in InstCombine.

• dfg/DFGStrengthReductionPhase.cpp:

(JSC::DFG::StrengthReductionPhase::handleNode):

• jit/JITDivGenerator.cpp:

(JSC::JITDivGenerator::loadOperand):
(JSC::JITDivGenerator::generateFastPath):

• jit/SnippetOperand.h:

(JSC::SnippetOperand::asConstNumber):

• runtime/MathCommon.h:

(JSC::safeReciprocalForDivByConst):

• tests/stress/floating-point-div-to-mul.js: Added.

(opaqueDivBy2):
(opaqueDivBy3):
(opaqueDivBy4):
(opaqueDivBySafeMaxMinusOne):
(opaqueDivBySafeMax):
(opaqueDivBySafeMaxPlusOne):
(opaqueDivBySafeMin):
(opaqueDivBySafeMinMinusOne):
(i.catch):
(i.result.opaqueDivBySafeMin.valueOf):

File:

• trunk/Source/JavaScriptCore/runtime/MathCommon.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/runtime/MathCommon.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2015-2016 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28 +28 @@
 
 #include "JITOperations.h"
+#include <wtf/Optional.h>
 
 #ifndef JIT_OPERATION
@@ -55 +56 @@
 }
 
+inline Optional<double> safeReciprocalForDivByConst(double constant)
+{
+    // No "weird" numbers (NaN, Denormal, etc).
+    if (!constant || !isnormal(constant))
+        return Nullopt;
+
+    int exponent;
+    if (frexp(constant, &exponent) != 0.5)
+        return Nullopt;
+
+    // Note that frexp() returns the value divided by two
+    // so we to offset this exponent by one.
+    exponent -= 1;
+
+    // A double exponent is between -1022 and 1023.
+    // Nothing we can do to invert 1023.
+    if (exponent == 1023)
+        return Nullopt;
+
+    double reciprocal = ldexp(1, -exponent);
+    ASSERT(isnormal(reciprocal));
+    ASSERT(1. / constant == reciprocal);
+    ASSERT(constant == 1. / reciprocal);
+    ASSERT(1. == constant * reciprocal);
+
+    return reciprocal;
+}
+
 extern "C" {
 double JIT_OPERATION jsRound(double value) REFERENCED_FROM_ASM WTF_INTERNAL;