Changeset 130839 in webkit for trunk/Source/JavaScriptCore/bytecode/ByValInfo.h

Timestamp:

Oct 9, 2012, 7:14:42 PM (13 years ago)

Author:

[email protected]

Message:

Typed arrays should not be 20x slower in the baseline JIT than in the DFG JIT
​https://bugs.webkit.org/show_bug.cgi?id=98605

Reviewed by Oliver Hunt and Gavin Barraclough.

This adds typed array get_by_val/put_by_val patching to the baseline JIT. It's
a big (~40%) win on benchmarks that have trouble staying in the DFG JIT. Even
if we fix those benchmarks, this functionality gives us the insurance that we
typically desire with all speculative optimizations: even if we bail to
baseline, we're still reasonably performant.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• assembler/MacroAssembler.cpp: Added.

(JSC):

• assembler/MacroAssembler.h:

(MacroAssembler):
(JSC::MacroAssembler::patchableBranchPtr):

• assembler/MacroAssemblerARMv7.h:

(MacroAssemblerARMv7):
(JSC::MacroAssemblerARMv7::moveDoubleToInts):
(JSC::MacroAssemblerARMv7::moveIntsToDouble):
(JSC::MacroAssemblerARMv7::patchableBranchPtr):

• assembler/MacroAssemblerX86.h:

(MacroAssemblerX86):
(JSC::MacroAssemblerX86::moveDoubleToInts):
(JSC::MacroAssemblerX86::moveIntsToDouble):

• bytecode/ByValInfo.h:

(JSC::hasOptimizableIndexingForClassInfo):
(JSC):
(JSC::hasOptimizableIndexing):
(JSC::jitArrayModeForClassInfo):
(JSC::jitArrayModeForStructure):
(JSC::ByValInfo::ByValInfo):
(ByValInfo):

• dfg/DFGAssemblyHelpers.cpp:

(DFG):

• dfg/DFGAssemblyHelpers.h:

(AssemblyHelpers):
(JSC::DFG::AssemblyHelpers::boxDouble):
(JSC::DFG::AssemblyHelpers::unboxDouble):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
(JSC::DFG::SpeculativeJIT::compilePutByValForIntTypedArray):

• dfg/DFGSpeculativeJIT.h:

(SpeculativeJIT):

• jit/JIT.h:

(JIT):

• jit/JITPropertyAccess.cpp:

(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::privateCompileGetByVal):
(JSC::JIT::privateCompilePutByVal):
(JSC::JIT::emitIntTypedArrayGetByVal):
(JSC):
(JSC::JIT::emitFloatTypedArrayGetByVal):
(JSC::JIT::emitIntTypedArrayPutByVal):
(JSC::JIT::emitFloatTypedArrayPutByVal):

• jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• runtime/JSCell.h:
• runtime/JSGlobalData.h:

(JSGlobalData):
(JSC::JSGlobalData::typedArrayDescriptor):

• runtime/TypedArrayDescriptor.h: Added.

(JSC):
(JSC::TypedArrayDescriptor::TypedArrayDescriptor):
(TypedArrayDescriptor):

File:

• trunk/Source/JavaScriptCore/bytecode/ByValInfo.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/bytecode/ByValInfo.h

@@ -31 +31 @@
 #if ENABLE(JIT)
 
+#include "ClassInfo.h"
 #include "CodeLocation.h"
 #include "IndexingType.h"
 #include "JITStubRoutine.h"
+#include "Structure.h"
 
 namespace JSC {
 
-enum JITArrayMode { JITContiguous, JITArrayStorage };
+enum JITArrayMode {
+    JITContiguous,
+    JITArrayStorage,
+    JITInt8Array,
+    JITInt16Array,
+    JITInt32Array,
+    JITUint8Array,
+    JITUint8ClampedArray,
+    JITUint16Array,
+    JITUint32Array,
+    JITFloat32Array,
+    JITFloat64Array
+};
 
 inline bool isOptimizableIndexingType(IndexingType indexingType)
@@ -48 +62 @@
         return false;
     }
+}
+
+inline bool hasOptimizableIndexingForClassInfo(const ClassInfo* classInfo)
+{
+    return classInfo->typedArrayStorageType != TypedArrayNone;
+}
+
+inline bool hasOptimizableIndexing(Structure* structure)
+{
+    return isOptimizableIndexingType(structure->indexingType())
+        || hasOptimizableIndexingForClassInfo(structure->classInfo());
 }
 
@@ -63 +88 @@
 }
 
+inline JITArrayMode jitArrayModeForClassInfo(const ClassInfo* classInfo)
+{
+    switch (classInfo->typedArrayStorageType) {
+    case TypedArrayInt8:
+        return JITInt8Array;
+    case TypedArrayInt16:
+        return JITInt16Array;
+    case TypedArrayInt32:
+        return JITInt32Array;
+    case TypedArrayUint8:
+        return JITUint8Array;
+    case TypedArrayUint8Clamped:
+        return JITUint8ClampedArray;
+    case TypedArrayUint16:
+        return JITUint16Array;
+    case TypedArrayUint32:
+        return JITUint32Array;
+    case TypedArrayFloat32:
+        return JITFloat32Array;
+    case TypedArrayFloat64:
+        return JITFloat64Array;
+    default:
+        CRASH();
+        return JITContiguous;
+    }
+}
+
+inline JITArrayMode jitArrayModeForStructure(Structure* structure)
+{
+    if (isOptimizableIndexingType(structure->indexingType()))
+        return jitArrayModeForIndexingType(structure->indexingType());
+    
+    ASSERT(hasOptimizableIndexingForClassInfo(structure->classInfo()));
+    return jitArrayModeForClassInfo(structure->classInfo());
+}
+
 struct ByValInfo {
     ByValInfo() { }
@@ -72 +133 @@
         , badTypeJumpToDone(badTypeJumpToDone)
         , returnAddressToSlowPath(returnAddressToSlowPath)
+        , slowPathCount(0)
     {
     }
@@ -80 +142 @@
     int16_t badTypeJumpToDone;
     int16_t returnAddressToSlowPath;
+    unsigned slowPathCount;
     RefPtr<JITStubRoutine> stubRoutine;
 };