Ignore:
Timestamp:
Oct 4, 2017, 1:00:01 PM (8 years ago)
Author:
[email protected]
Message:

Add support for using Probe DFG OSR Exit behind a runtime flag.
​https://bugs.webkit.org/show_bug.cgi?id=177844
<rdar://problem/34801425>

Reviewed by Saam Barati.

Source/JavaScriptCore:

This is based on the code originally posted in ​https://bugs.webkit.org/show_bug.cgi?id=175144
(in r221774 and r221832) with some optimizations and bug fixes added. The probe
based DFG OSR Exit is only enabled if Options::useProbeOSRExit() is true. We're
landing this behind an option switch to make it easier to tune performance using
the probe based OSR exit.

  • JavaScriptCore.xcodeproj/project.pbxproj:
  • assembler/MacroAssembler.cpp:

(JSC::stdFunctionCallback):

  • assembler/MacroAssemblerPrinter.cpp:

(JSC::Printer::printCallback):

  • assembler/ProbeContext.cpp:

(JSC::Probe::executeProbe):
(JSC::Probe::flushDirtyStackPages):

  • assembler/ProbeContext.h:

(JSC::Probe::Context::Context):
(JSC::Probe::Context::arg):

  • assembler/ProbeFrame.h: Added.

(JSC::Probe::Frame::Frame):
(JSC::Probe::Frame::argument):
(JSC::Probe::Frame::operand):
(JSC::Probe::Frame::setArgument):
(JSC::Probe::Frame::setOperand):
(JSC::Probe::Frame::get):
(JSC::Probe::Frame::set):

  • assembler/ProbeStack.cpp:

(JSC::Probe::Page::lowWatermarkFromVisitingDirtyChunks):
(JSC::Probe::Stack::Stack):
(JSC::Probe::Stack::lowWatermarkFromVisitingDirtyPages):

  • assembler/ProbeStack.h:

(JSC::Probe::Stack::Stack):
(JSC::Probe::Stack::lowWatermark):
(JSC::Probe::Stack::set):
(JSC::Probe::Stack::savedStackPointer const):
(JSC::Probe::Stack::setSavedStackPointer):
(JSC::Probe::Stack::newStackPointer const): Deleted.
(JSC::Probe::Stack::setNewStackPointer): Deleted.

  • bytecode/ArrayProfile.h:

(JSC::ArrayProfile::observeArrayMode):

  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::updateOSRExitCounterAndCheckIfNeedToReoptimize):

  • bytecode/CodeBlock.h:

(JSC::CodeBlock::addressOfOSRExitCounter): Deleted.

  • bytecode/ExecutionCounter.h:

(JSC::ExecutionCounter::hasCrossedThreshold const):
(JSC::ExecutionCounter::setNewThresholdForOSRExit):

  • bytecode/MethodOfGettingAValueProfile.cpp:

(JSC::MethodOfGettingAValueProfile::reportValue):

  • bytecode/MethodOfGettingAValueProfile.h:
  • dfg/DFGDriver.cpp:

(JSC::DFG::compileImpl):

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::linkOSRExits):
(JSC::DFG::JITCompiler::link):

  • dfg/DFGOSRExit.cpp:

(JSC::DFG::jsValueFor):
(JSC::DFG::restoreCalleeSavesFor):
(JSC::DFG::saveCalleeSavesFor):
(JSC::DFG::restoreCalleeSavesFromVMEntryFrameCalleeSavesBuffer):
(JSC::DFG::copyCalleeSavesToVMEntryFrameCalleeSavesBuffer):
(JSC::DFG::saveOrCopyCalleeSavesFor):
(JSC::DFG::createDirectArgumentsDuringExit):
(JSC::DFG::createClonedArgumentsDuringExit):
(JSC::DFG::emitRestoreArguments):
(JSC::DFG::OSRExit::executeOSRExit):
(JSC::DFG::reifyInlinedCallFrames):
(JSC::DFG::adjustAndJumpToTarget):
(JSC::DFG::printOSRExit):

  • dfg/DFGOSRExit.h:

(JSC::DFG::OSRExitState::OSRExitState):

  • dfg/DFGThunks.cpp:

(JSC::DFG::osrExitThunkGenerator):

  • dfg/DFGThunks.h:
  • dfg/DFGVariableEventStream.cpp:

(JSC::DFG::tryToSetConstantRecovery):
(JSC::DFG::VariableEventStream::reconstruct const):
(JSC::DFG::VariableEventStream::tryToSetConstantRecovery const): Deleted.

  • dfg/DFGVariableEventStream.h:
  • profiler/ProfilerOSRExit.h:

(JSC::Profiler::OSRExit::incCount):

  • runtime/JSCJSValue.h:
  • runtime/JSCJSValueInlines.h:
  • runtime/Options.h:

Tools:

Enable --useProbeOSrExit=true for dfg-eager and ftl-no-cjit-validate-sampling-profiler
test configurations.

  • Scripts/run-jsc-stress-tests:
Location:
trunk/Source/JavaScriptCore/assembler
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/assembler/MacroAssembler.cpp

    r222009 r222871  
    3939static void stdFunctionCallback(Probe::Context& context)
    4040{
    41     auto func = static_cast<const std::function<void(Probe::Context&)>*>(context.arg);
     41    auto func = context.arg<const std::function<void(Probe::Context&)>*>();
    4242    (*func)(context);
    4343}

  • trunk/Source/JavaScriptCore/assembler/MacroAssemblerPrinter.cpp

    r222009 r222871  
    176176{
    177177    auto& out = WTF::dataFile();
    178     PrintRecordList& list = *reinterpret_cast<PrintRecordList*>(probeContext.arg);
     178    PrintRecordList& list = *probeContext.arg<PrintRecordList*>();
    179179    for (size_t i = 0; i < list.size(); i++) {
    180180        auto& record = list[i];

  • trunk/Source/JavaScriptCore/assembler/ProbeContext.cpp

    r220960 r222871  
    5353
    5454    if (context.hasWritesToFlush()) {
    55         context.stack().setNewStackPointer(state->cpu.sp());
    56         state->cpu.sp() = std::min(context.stack().lowWatermark(), state->cpu.sp());
     55        context.stack().setSavedStackPointer(state->cpu.sp());
     56        void* lowWatermark = context.stack().lowWatermark(state->cpu.sp());
     57        state->cpu.sp() = std::min(lowWatermark, state->cpu.sp());
    5758
    5859        state->initializeStackFunction = flushDirtyStackPages;
    … …  
    6566    std::unique_ptr<Stack> stack(reinterpret_cast<Probe::Stack*>(state->initializeStackArg));
    6667    stack->flushWrites();
    67     state->cpu.sp() = stack->newStackPointer();
     68    state->cpu.sp() = stack->savedStackPointer();
    6869}
    6970

  • trunk/Source/JavaScriptCore/assembler/ProbeContext.h

    r222058 r222871  
    192192
    193193    Context(State* state)
    194         : m_state(state)
    195         , arg(state->arg)
    196         , cpu(state->cpu)
     194        : cpu(state->cpu)
     195        , m_state(state)
    197196    { }
     197
     198    template<typename T>
     199    T arg() { return reinterpret_cast<T>(m_state->arg); }
    198200
    199201    uintptr_t& gpr(RegisterID id) { return cpu.gpr(id); }
    … …  
    225227    Stack* releaseStack() { return new Stack(WTFMove(m_stack)); }
    226228
     229    CPUState& cpu;
     230
    227231private:
    228232    State* m_state;
    229 public:
    230     void* arg;
    231     CPUState& cpu;
    232 
    233 private:
    234233    Stack m_stack;
    235234

  • trunk/Source/JavaScriptCore/assembler/ProbeStack.cpp

    r222058 r222871  
    3535namespace Probe {
    3636
     37static void* const maxLowWatermark = reinterpret_cast<void*>(std::numeric_limits<uintptr_t>::max());
     38
    3739#if ASAN_ENABLED
    3840// FIXME: we should consider using the copy function for both ASan and non-ASan builds.
    … …  
    5052}
    5153#else
    52 #define copyStackPage(dst, src, size) std::memcpy(dst, src, size);
     54#define copyStackPage(dst, src, size) std::memcpy(dst, src, size)
    5355#endif
    5456
    … …  
    8587}
    8688
     89void* Page::lowWatermarkFromVisitingDirtyChunks()
     90{
     91    uint64_t dirtyBits = m_dirtyBits;
     92    size_t offset = 0;
     93    while (dirtyBits) {
     94        if (dirtyBits & 1)
     95            return reinterpret_cast<uint8_t*>(m_baseLogicalAddress) + offset;
     96        dirtyBits = dirtyBits >> 1;
     97        offset += s_chunkSize;
     98    }
     99    return maxLowWatermark;
     100}
     101
    87102Stack::Stack(Stack&& other)
    88     : m_newStackPointer(other.m_newStackPointer)
    89     , m_lowWatermark(other.m_lowWatermark)
    90     , m_stackBounds(WTFMove(other.m_stackBounds))
     103    : m_stackBounds(WTFMove(other.m_stackBounds))
    91104    , m_pages(WTFMove(other.m_pages))
    92105{
     106    m_savedStackPointer = other.m_savedStackPointer;
    93107#if !ASSERT_DISABLED
    94108    other.m_isValid = false;
    … …  
    129143}
    130144
     145void* Stack::lowWatermarkFromVisitingDirtyPages()
     146{
     147    void* low = maxLowWatermark;
     148    for (auto it = m_pages.begin(); it != m_pages.end(); ++it) {
     149        Page& page = *it->value;
     150        if (!page.hasWritesToFlush() || low < page.baseAddress())
     151            continue;
     152        low = std::min(low, page.lowWatermarkFromVisitingDirtyChunks());
     153    }
     154    return low;
     155}
     156
    131157} // namespace Probe
    132158} // namespace JSC

  • trunk/Source/JavaScriptCore/assembler/ProbeStack.h

    r222058 r222871  
    9696    }
    9797
     98    void* lowWatermarkFromVisitingDirtyChunks();
     99
    98100private:
    99101    uint64_t dirtyBitFor(void* logicalAddress)
    … …  
    147149public:
    148150    Stack()
    149         : m_lowWatermark(reinterpret_cast<void*>(-1))
    150         , m_stackBounds(Thread::current().stack())
     151        : m_stackBounds(Thread::current().stack())
    151152    { }
    152153    Stack(Stack&& other);
    153154
    154     void* lowWatermark()
    155     {
    156         // We use the chunkAddress for the low watermark because we'll be doing write backs
    157         // to the stack in increments of chunks. Hence, we'll treat the lowest address of
    158         // the chunk as the low watermark of any given set address.
    159         return Page::chunkAddressFor(m_lowWatermark);
     155    void* lowWatermarkFromVisitingDirtyPages();
     156    void* lowWatermark(void* stackPointer)
     157    {
     158        ASSERT(Page::chunkAddressFor(stackPointer) == lowWatermarkFromVisitingDirtyPages());
     159        return Page::chunkAddressFor(stackPointer);
    160160    }
    161161
    … …  
    177177        Page* page = pageFor(address);
    178178        page->set<T>(address, value);
    179 
    180         if (address < m_lowWatermark)
    181             m_lowWatermark = address;
    182179    }
    183180
    … …  
    190187    JS_EXPORT_PRIVATE Page* ensurePageFor(void* address);
    191188
    192     void* newStackPointer() const { return m_newStackPointer; };
    193     void setNewStackPointer(void* sp) { m_newStackPointer = sp; };
     189    void* savedStackPointer() const { return m_savedStackPointer; }
     190    void setSavedStackPointer(void* sp) { m_savedStackPointer = sp; }
    194191
    195192    bool hasWritesToFlush();
    … …  
    208205    }
    209206
    210     void* m_newStackPointer { nullptr };
    211     void* m_lowWatermark;
     207    void* m_savedStackPointer { nullptr };
    212208
    213209    // A cache of the last accessed page details for quick access.
Note: See TracChangeset for help on using the changeset viewer.