Changeset 37213 in webkit for trunk/JavaScriptCore/VM


Ignore:
Timestamp:
Oct 2, 2008, 3:19:05 PM (17 years ago)
Author:
[email protected]
Message:

2008-10-02 Cameron Zwarich <​[email protected]>

Reviewed by Geoff Garen.

Bug 21317: Replace RegisterFile size and capacity information with Register pointers
<​https://bugs.webkit.org/show_bug.cgi?id=21317>

This is a 2.3% speedup on the V8 DeltaBlue benchmark, a 3.3% speedup on
the V8 Raytrace benchmark, and a 1.0% speedup on SunSpider.

  • VM/Machine.cpp: (JSC::slideRegisterWindowForCall): (JSC::Machine::callEval): (JSC::Machine::execute): (JSC::Machine::privateExecute): (JSC::Machine::cti_op_call_JSFunction): (JSC::Machine::cti_op_construct_JSConstruct):
  • VM/RegisterFile.cpp: (JSC::RegisterFile::~RegisterFile):
  • VM/RegisterFile.h: (JSC::RegisterFile::RegisterFile): (JSC::RegisterFile::start): (JSC::RegisterFile::end): (JSC::RegisterFile::size): (JSC::RegisterFile::shrink): (JSC::RegisterFile::grow): (JSC::RegisterFile::lastGlobal): (JSC::RegisterFile::markGlobals): (JSC::RegisterFile::markCallFrames):
  • kjs/JSGlobalObject.cpp: (JSC::JSGlobalObject::copyGlobalsTo):
Location:
trunk/JavaScriptCore/VM
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/VM/Machine.cpp

    r37191 r37213  
    533533}
    534534
    535 ALWAYS_INLINE Register* slideRegisterWindowForCall(ExecState* exec, CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* registerBase, Register* r, size_t registerOffset, int argc, JSValue*& exceptionValue)
    536 {
    537     size_t size = r - registerBase + registerOffset + newCodeBlock->numCalleeRegisters;
     535ALWAYS_INLINE Register* slideRegisterWindowForCall(ExecState* exec, CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* r, size_t registerOffset, int argc, JSValue*& exceptionValue)
     536{
     537    Register* newEnd = r + registerOffset + newCodeBlock->numCalleeRegisters;
    538538
    539539    if (argc == newCodeBlock->numParameters) { // correct number of arguments
    540         if (!registerFile->grow(size)) {
     540        if (!registerFile->grow(newEnd)) {
    541541            exceptionValue = createStackOverflowError(exec);
    542542            return r;
    … …  
    546546        size_t omittedArgCount = newCodeBlock->numParameters - argc;
    547547        registerOffset += omittedArgCount;
    548         size += omittedArgCount;
    549         if (!registerFile->grow(size)) {
     548        newEnd += omittedArgCount;
     549        if (!registerFile->grow(newEnd)) {
    550550            exceptionValue = createStackOverflowError(exec);
    551551            return r;
    … …  
    559559        size_t numParameters = newCodeBlock->numParameters;
    560560        registerOffset += numParameters;
    561         size += numParameters;
    562 
    563         if (!registerFile->grow(size)) {
     561        newEnd += numParameters;
     562
     563        if (!registerFile->grow(newEnd)) {
    564564            exceptionValue = createStackOverflowError(exec);
    565565            return r;
    … …  
    604604    JSValue* result = 0;
    605605    if (evalNode)
    606         result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - registerFile->base() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
     606        result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - registerFile->start() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
    607607
    608608    if (*profiler)
    … …  
    887887    CodeBlock* codeBlock = &programNode->byteCode(scopeChain);
    888888
    889     size_t oldSize = m_registerFile.size();
    890     size_t newSize = oldSize + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->numCalleeRegisters;
    891     if (!m_registerFile.grow(newSize)) {
     889    Register* oldEnd = m_registerFile.end();
     890    Register* newEnd = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->numCalleeRegisters;
     891    if (!m_registerFile.grow(newEnd)) {
    892892        *exception = createStackOverflowError(exec);
    893893        return jsNull();
    … …  
    898898    globalObject->copyGlobalsTo(m_registerFile);
    899899
    900     Register* r = m_registerFile.base() + oldSize + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize;
     900    Register* r = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize;
    901901    r[codeBlock->thisRegister] = thisObj;
    902902    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(0), 0, 0, 0);
    … …  
    929929        lastGlobalObject->copyGlobalsTo(m_registerFile);
    930930
    931     m_registerFile.shrink(oldSize);
     931    m_registerFile.shrink(oldEnd);
    932932    return result;
    933933}
    … …  
    942942    }
    943943
    944     size_t oldSize = m_registerFile.size();
     944    Register* oldEnd = m_registerFile.end();
    945945    int argc = 1 + args.size(); // implicit "this" parameter
    946946
    947     if (!m_registerFile.grow(oldSize + argc)) {
     947    if (!m_registerFile.grow(oldEnd + argc)) {
    948948        *exception = createStackOverflowError(exec);
    949949        return jsNull();
    950950    }
    951951
    952     Register* argv = m_registerFile.base() + oldSize;
     952    Register* argv = oldEnd;
    953953    size_t dst = 0;
    954954    argv[dst] = thisObj;
    … …  
    959959
    960960    CodeBlock* codeBlock = &functionBodyNode->byteCode(scopeChain);
    961     Register* r = slideRegisterWindowForCall(exec, codeBlock, &m_registerFile, m_registerFile.base(), argv, argc + RegisterFile::CallFrameHeaderSize, argc, *exception);
     961    Register* r = slideRegisterWindowForCall(exec, codeBlock, &m_registerFile, argv, argc + RegisterFile::CallFrameHeaderSize, argc, *exception);
    962962    if (UNLIKELY(*exception != 0)) {
    963         m_registerFile.shrink(oldSize);
     963        m_registerFile.shrink(oldEnd);
    964964        return jsNull();
    965965    }
    … …  
    985985    MACHINE_SAMPLING_privateExecuteReturned();
    986986
    987     m_registerFile.shrink(oldSize);
     987    m_registerFile.shrink(oldEnd);
    988988    return result;
    989989}
    … …  
    10371037    }
    10381038
    1039     size_t oldSize = m_registerFile.size();
    1040     size_t newSize = registerOffset + codeBlock->numCalleeRegisters;
    1041     if (!m_registerFile.grow(newSize)) {
     1039    Register* oldEnd = m_registerFile.end();
     1040    Register* newEnd = m_registerFile.start() + registerOffset + codeBlock->numCalleeRegisters;
     1041    if (!m_registerFile.grow(newEnd)) {
    10421042        *exception = createStackOverflowError(exec);
    10431043        return jsNull();
    10441044    }
    10451045
    1046     Register* r = m_registerFile.base() + registerOffset;
     1046    Register* r = m_registerFile.start() + registerOffset;
    10471047
    10481048    // a 0 codeBlock indicates a built-in caller
    … …  
    10741074        (*profiler)->didExecute(exec, evalNode->sourceURL(), evalNode->lineNo());
    10751075
    1076     m_registerFile.shrink(oldSize);
     1076    m_registerFile.shrink(oldEnd);
    10771077    return result;
    10781078}
    … …  
    14471447    Instruction* handlerVPC = 0;
    14481448
    1449     Register* registerBase = registerFile->base();
    14501449    Instruction* vPC = this->codeBlock(r)->instructions.begin();
    14511450    Profiler** enabledProfilerReference = Profiler::enabledProfilerReference();
    … …  
    32853284            Register* savedR = r;
    32863285
    3287             r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, registerOffset, argCount, exceptionValue);
     3286            r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, r, registerOffset, argCount, exceptionValue);
    32883287            exec->m_callFrame = r;
    32893288            if (UNLIKELY(exceptionValue != 0))
    … …  
    34683467            Register* savedR = r;
    34693468
    3470             r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, registerOffset, argCount, exceptionValue);
     3469            r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, r, registerOffset, argCount, exceptionValue);
    34713470            exec->m_callFrame = r;
    34723471            if (UNLIKELY(exceptionValue != 0))
    … …  
    44904489    Register* r = ARG_r;
    44914490
    4492     Register* registerBase = registerFile->base();
    4493    
    44944491    JSValue* funcVal = ARG_src1;
    44954492    int registerOffset = ARG_int2;
    … …  
    45124509
    45134510    JSValue* exceptionValue = 0;
    4514     r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, registerOffset, argCount, exceptionValue);
     4511    r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, r, registerOffset, argCount, exceptionValue);
    45154512    JSVALUE_VM_CHECK_EXCEPTION_ARG(exceptionValue);
    45164513
    … …  
    46914688    Register* r = ARG_r;
    46924689
    4693     Register* registerBase = registerFile->base();
    4694    
    46954690    JSValue* constrVal = ARG_src1;
    46964691    JSValue* constrProtoVal = ARG_src2;
    … …  
    47254720
    47264721    JSValue* exceptionValue = 0;
    4727     r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, registerBase, r, registerOffset, argCount, exceptionValue);
     4722    r = slideRegisterWindowForCall(exec, newCodeBlock, registerFile, r, registerOffset, argCount, exceptionValue);
    47284723    JSVALUE_VM_CHECK_EXCEPTION_ARG(exceptionValue);
    47294724

  • trunk/JavaScriptCore/VM/RegisterFile.cpp

    r36263 r37213  
    3535{
    3636#if HAVE(MMAP)
    37     munmap(m_buffer, (m_capacity + m_maxGlobals) * sizeof(Register));
     37    munmap(m_buffer, ((m_max - m_start) + m_maxGlobals) * sizeof(Register));
    3838#elif HAVE(VIRTUALALLOC)
    3939    // FIXME: Use VirtualFree.

  • trunk/JavaScriptCore/VM/RegisterFile.h

    r37160 r37213  
    111111
    112112        RegisterFile(size_t capacity = DefaultCapacity, size_t maxGlobals = DefaultMaxGlobals)
    113             : m_size(0)
    114             , m_capacity(capacity)
    115             , m_numGlobals(0)
     113            : m_numGlobals(0)
    116114            , m_maxGlobals(maxGlobals)
    117             , m_base(0)
     115            , m_start(0)
     116            , m_end(0)
     117            , m_max(0)
    118118            , m_buffer(0)
    119119            , m_globalObject(0)
    … …  
    129129            #error "Don't know how to reserve virtual memory on this platform."
    130130#endif
    131             m_base = m_buffer + maxGlobals;
     131            m_start = m_buffer + maxGlobals;
     132            m_end = m_start;
     133            m_max = m_start + capacity;
    132134        }
    133135
    134136        ~RegisterFile();
    135137
    136         Register* base() const { return m_base; }
    137        
     138        Register* start() const { return m_start; }
     139        Register* end() const { return m_end; }
     140        size_t size() const { return m_end - m_start; }
     141
    138142        void setGlobalObject(JSGlobalObject* globalObject) { m_globalObject = globalObject; }
    139143        JSGlobalObject* globalObject() { return m_globalObject; }
    140144
    141         void shrink(size_t size)
     145        void shrink(Register* newEnd)
    142146        {
    143             if (size < m_size)
    144                 m_size = size;
     147            if (newEnd < m_end)
     148                m_end = newEnd;
    145149        }
    146150
    147         bool grow(size_t size)
     151        bool grow(Register* newEnd)
    148152        {
    149             if (size > m_size) {
    150                 if (size > m_capacity)
     153            if (newEnd > m_end) {
     154                if (newEnd > m_max)
    151155                    return false;
    152156#if !HAVE(MMAP) && HAVE(VIRTUALALLOC)
    153157                // FIXME: Use VirtualAlloc, and commit pages as we go.
    154158#endif
    155                 m_size = size;
     159                m_end = newEnd;
    156160            }
    157161            return true;
    158162        }
    159 
    160         size_t size() const { return m_size; }
    161163       
    162164        void setNumGlobals(size_t numGlobals) { m_numGlobals = numGlobals; }
    … …  
    164166        size_t maxGlobals() const { return m_maxGlobals; }
    165167
    166         Register* lastGlobal() const { return m_base - m_numGlobals; }
     168        Register* lastGlobal() const { return m_start - m_numGlobals; }
    167169       
    168         void markGlobals(Heap* heap) { heap->markConservatively(lastGlobal(), m_base); }
    169         void markCallFrames(Heap* heap) { heap->markConservatively(m_base, m_base + m_size); }
     170        void markGlobals(Heap* heap) { heap->markConservatively(lastGlobal(), m_start); }
     171        void markCallFrames(Heap* heap) { heap->markConservatively(m_start, m_end); }
    170172
    171173    private:
    172         size_t m_size;
    173         const size_t m_capacity;
    174174        size_t m_numGlobals;
    175175        const size_t m_maxGlobals;
    176         Register* m_base;
     176        Register* m_start;
     177        Register* m_end;
     178        Register* m_max;
    177179        Register* m_buffer;
    178180        JSGlobalObject* m_globalObject; // The global object whose vars are currently stored in the register file.
Note: See TracChangeset for help on using the changeset viewer.