Changeset 175593 in webkit


Ignore:
Timestamp:
Nov 4, 2014 5:19:37 PM (9 years ago)
Author:
mark.lam@apple.com
Message:

Rename checkMarkByte() to jumpIfIsRememberedOrInEden().
<https://webkit.org/b/138369>

Reviewed by Geoffrey Garen.

Write barriers are needed for GC Eden collections so that we can scan pointers
pointing from old generation objects to eden generation objects. The barrier
currently checks the mark byte in a cell to see if we should skip adding the
cell to the GC remembered set. The addition should be skipped if:

  1. The cell is in the young generation. It has no old to eden pointers by definition.
  2. The cell is already in the remembered set. While it is ok to add the cell to the GC remembered set more than once, it would be redundant. Hence, we skip this as an optimization to avoid doing unnecessary work.

The barrier currently names this check as checkMarkByte(). We should rename it
to jumpIfIsRememberedOrInEden() to be clearer about its intent.

Similarly, Jump results of this check are currently named
ownerNotMarkedOrAlreadyRemembered. This can be misinterpreted as the owner is
not marked or not already remembered. We should rename it to
ownerIsRememberedOrInEden which is clearer about the intent of the
check. What we are really checking for is that the cell is in the eden gen,
which is implied by it being "not marked".

  • dfg/DFGOSRExitCompilerCommon.cpp:

(JSC::DFG::osrWriteBarrier):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::writeBarrier):

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::writeBarrier):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::writeBarrier):

  • jit/AssemblyHelpers.h:

(JSC::AssemblyHelpers::jumpIfIsRememberedOrInEden):
(JSC::AssemblyHelpers::checkMarkByte): Deleted.

  • jit/JITPropertyAccess.cpp:

(JSC::JIT::emitWriteBarrier):

  • llint/LowLevelInterpreter.asm:
  • llint/LowLevelInterpreter32_64.asm:
  • llint/LowLevelInterpreter64.asm:
  • runtime/JSCell.h:
Location:
trunk/Source/JavaScriptCore
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r175588 r175593  
     12014-11-04  Mark Lam  <mark.lam@apple.com>
     2
     3        Rename checkMarkByte() to jumpIfIsRememberedOrInEden().
     4        <https://webkit.org/b/138369>
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        Write barriers are needed for GC Eden collections so that we can scan pointers
     9        pointing from old generation objects to eden generation objects.  The barrier
     10        currently checks the mark byte in a cell to see if we should skip adding the
     11        cell to the GC remembered set.  The addition should be skipped if:
     12
     13        1. The cell is in the young generation.  It has no old to eden pointers by
     14           definition.
     15        2. The cell is already in the remembered set.  While it is ok to add the cell
     16           to the GC remembered set more than once, it would be redundant.  Hence,
     17           we skip this as an optimization to avoid doing unnecessary work.
     18
     19        The barrier currently names this check as checkMarkByte().  We should rename it
     20        to jumpIfIsRememberedOrInEden() to be clearer about its intent.
     21
     22        Similarly, Jump results of this check are currently named
     23        ownerNotMarkedOrAlreadyRemembered.  This can be misinterpreted as the owner is
     24        not marked or not already remembered.  We should rename it to
     25        ownerIsRememberedOrInEden which is clearer about the intent of the
     26        check.  What we are really checking for is that the cell is in the eden gen,
     27        which is implied by it being "not marked".
     28
     29        * dfg/DFGOSRExitCompilerCommon.cpp:
     30        (JSC::DFG::osrWriteBarrier):
     31        * dfg/DFGSpeculativeJIT.cpp:
     32        (JSC::DFG::SpeculativeJIT::writeBarrier):
     33        * dfg/DFGSpeculativeJIT32_64.cpp:
     34        (JSC::DFG::SpeculativeJIT::writeBarrier):
     35        * dfg/DFGSpeculativeJIT64.cpp:
     36        (JSC::DFG::SpeculativeJIT::writeBarrier):
     37        * jit/AssemblyHelpers.h:
     38        (JSC::AssemblyHelpers::jumpIfIsRememberedOrInEden):
     39        (JSC::AssemblyHelpers::checkMarkByte): Deleted.
     40        * jit/JITPropertyAccess.cpp:
     41        (JSC::JIT::emitWriteBarrier):
     42        * llint/LowLevelInterpreter.asm:
     43        * llint/LowLevelInterpreter32_64.asm:
     44        * llint/LowLevelInterpreter64.asm:
     45        * runtime/JSCell.h:
     46
    1472014-11-04  Joseph Pecoraro  <pecoraro@apple.com>
    248
  • trunk/Source/JavaScriptCore/dfg/DFGOSRExitCompilerCommon.cpp

    r174371 r175593  
    249249static void osrWriteBarrier(CCallHelpers& jit, GPRReg owner, GPRReg scratch)
    250250{
    251     AssemblyHelpers::Jump ownerNotMarkedOrAlreadyRemembered = jit.checkMarkByte(owner);
     251    AssemblyHelpers::Jump ownerIsRememberedOrInEden = jit.jumpIfIsRememberedOrInEden(owner);
    252252
    253253    // We need these extra slots because setupArgumentsWithExecState will use poke on x86.
     
    264264#endif
    265265
    266     ownerNotMarkedOrAlreadyRemembered.link(&jit);
     266    ownerIsRememberedOrInEden.link(&jit);
    267267}
    268268#endif // ENABLE(GGC)
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r174795 r175593  
    54735473        return;
    54745474
    5475     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(ownerGPR);
     5475    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(ownerGPR);
    54765476    storeToWriteBarrierBuffer(ownerGPR, scratch1, scratch2);
    5477     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     5477    ownerIsRememberedOrInEden.link(&m_jit);
    54785478}
    54795479
    54805480void SpeculativeJIT::writeBarrier(GPRReg ownerGPR, GPRReg scratch1, GPRReg scratch2)
    54815481{
    5482     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(ownerGPR);
     5482    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(ownerGPR);
    54835483    storeToWriteBarrierBuffer(ownerGPR, scratch1, scratch2);
    5484     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     5484    ownerIsRememberedOrInEden.link(&m_jit);
    54855485}
    54865486#else
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r174226 r175593  
    49424942        isNotCell = m_jit.branch32(JITCompiler::NotEqual, valueTagGPR, JITCompiler::TrustedImm32(JSValue::CellTag));
    49434943
    4944     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(ownerGPR);
     4944    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(ownerGPR);
    49454945    storeToWriteBarrierBuffer(ownerGPR, scratch1, scratch2);
    4946     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     4946    ownerIsRememberedOrInEden.link(&m_jit);
    49474947
    49484948    if (!isKnownCell(valueUse.node()))
     
    49564956        isNotCell = m_jit.branch32(JITCompiler::NotEqual, valueTagGPR, JITCompiler::TrustedImm32(JSValue::CellTag));
    49574957
    4958     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(owner);
     4958    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(owner);
    49594959    storeToWriteBarrierBuffer(owner, scratch1, scratch2);
    4960     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     4960    ownerIsRememberedOrInEden.link(&m_jit);
    49614961
    49624962    if (!isKnownCell(valueUse.node()))
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r174226 r175593  
    50325032        isNotCell = branchNotCell(JSValueRegs(valueGPR));
    50335033   
    5034     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(ownerGPR);
     5034    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(ownerGPR);
    50355035    storeToWriteBarrierBuffer(ownerGPR, scratch1, scratch2);
    5036     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     5036    ownerIsRememberedOrInEden.link(&m_jit);
    50375037
    50385038    if (!isKnownCell(valueUse.node()))
     
    50465046        isNotCell = branchNotCell(JSValueRegs(valueGPR));
    50475047   
    5048     JITCompiler::Jump ownerNotMarkedOrAlreadyRemembered = m_jit.checkMarkByte(owner);
     5048    JITCompiler::Jump ownerIsRememberedOrInEden = m_jit.jumpIfIsRememberedOrInEden(owner);
    50495049    storeToWriteBarrierBuffer(owner, scratch1, scratch2);
    5050     ownerNotMarkedOrAlreadyRemembered.link(&m_jit);
     5050    ownerIsRememberedOrInEden.link(&m_jit);
    50515051
    50525052    if (!isKnownCell(valueUse.node()))
  • trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h

    r173222 r175593  
    666666    static void emitStoreStructureWithTypeInfo(AssemblyHelpers& jit, TrustedImmPtr structure, RegisterID dest);
    667667
    668     Jump checkMarkByte(GPRReg cell)
     668    Jump jumpIfIsRememberedOrInEden(GPRReg cell)
    669669    {
    670670        return branchTest8(MacroAssembler::NonZero, MacroAssembler::Address(cell, JSCell::gcDataOffset()));
    671671    }
    672672
    673     Jump checkMarkByte(JSCell* cell)
     673    Jump jumpIfIsRememberedOrInEden(JSCell* cell)
    674674    {
    675675        uint8_t* address = reinterpret_cast<uint8_t*>(cell) + JSCell::gcDataOffset();
  • trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp

    r175471 r175593  
    829829        ownerNotCell = branchTest64(NonZero, regT0, tagMaskRegister);
    830830
    831     Jump ownerNotMarkedOrAlreadyRemembered = checkMarkByte(regT0);
     831    Jump ownerIsRememberedOrInEden = jumpIfIsRememberedOrInEden(regT0);
    832832    callOperation(operationUnconditionalWriteBarrier, regT0);
    833     ownerNotMarkedOrAlreadyRemembered.link(this);
     833    ownerIsRememberedOrInEden.link(this);
    834834
    835835    if (mode == ShouldFilterBaseAndValue || mode == ShouldFilterBase)
     
    879879        ownerNotCell = branch32(NotEqual, regT0, TrustedImm32(JSValue::CellTag));
    880880
    881     Jump ownerNotMarkedOrAlreadyRemembered = checkMarkByte(regT1);
     881    Jump ownerIsRememberedOrInEden = jumpIfIsRememberedOrInEden(regT1);
    882882    callOperation(operationUnconditionalWriteBarrier, regT1);
    883     ownerNotMarkedOrAlreadyRemembered.link(this);
     883    ownerIsRememberedOrInEden.link(this);
    884884
    885885    if (mode == ShouldFilterBase || mode == ShouldFilterBaseAndValue)
     
    920920#if ENABLE(GGC)
    921921    if (!MarkedBlock::blockFor(owner)->isMarked(owner)) {
    922         Jump ownerNotMarkedOrAlreadyRemembered = checkMarkByte(owner);
     922        Jump ownerIsRememberedOrInEden = jumpIfIsRememberedOrInEden(owner);
    923923        callOperation(operationUnconditionalWriteBarrier, owner);
    924         ownerNotMarkedOrAlreadyRemembered.link(this);
     924        ownerIsRememberedOrInEden.link(this);
    925925    } else
    926926        callOperation(operationUnconditionalWriteBarrier, owner);
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter.asm

    r175426 r175593  
    510510end
    511511
    512 macro checkMarkByte(cell, scratch1, scratch2, continuation)
     512macro skipIfIsRememberedOrInEden(cell, scratch1, scratch2, continuation)
    513513    loadb JSCell::m_gcData[cell], scratch1
    514514    continuation(scratch1)
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm

    r175508 r175593  
    570570        loadisFromInstruction(cellOperand, t1)
    571571        loadConstantOrVariablePayload(t1, CellTag, t2, .writeBarrierDone)
    572         checkMarkByte(t2, t1, t3,
     572        skipIfIsRememberedOrInEden(t2, t1, t3,
    573573            macro(gcData)
    574574                btbnz gcData, .writeBarrierDone
     
    604604        loadp CodeBlock[cfr], t3
    605605        loadp CodeBlock::m_globalObject[t3], t3
    606         checkMarkByte(t3, t1, t2,
     606        skipIfIsRememberedOrInEden(t3, t1, t2,
    607607            macro(gcData)
    608608                btbnz gcData, .writeBarrierDone
  • trunk/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm

    r175508 r175593  
    444444        loadisFromInstruction(cellOperand, t1)
    445445        loadConstantOrVariableCell(t1, t2, .writeBarrierDone)
    446         checkMarkByte(t2, t1, t3,
     446        skipIfIsRememberedOrInEden(t2, t1, t3,
    447447            macro(gcData)
    448448                btbnz gcData, .writeBarrierDone
     
    475475        loadp CodeBlock[cfr], t3
    476476        loadp CodeBlock::m_globalObject[t3], t3
    477         checkMarkByte(t3, t1, t2,
     477        skipIfIsRememberedOrInEden(t3, t1, t2,
    478478            macro(gcData)
    479479                btbnz gcData, .writeBarrierDone
  • trunk/Source/JavaScriptCore/runtime/JSCell.h

    r174122 r175593  
    148148
    149149    enum GCData : uint8_t {
    150         Marked = 0,
    151         NotMarked = 1,
    152         MarkedAndRemembered = 2,
     150        Marked = 0, // The object has survived a GC and is in the old gen.
     151        NotMarked = 1, // The object is new and in the eden gen.
     152        MarkedAndRemembered = 2, // The object is in the GC's remembered set.
     153
     154        // The object being in the GC's remembered set implies that it is also
     155        // Marked. This is because objects are only added to the remembered sets
     156        // by write barriers, and write barriers are only interested in old gen
     157        // objects that point to potential eden gen objects.
    153158    };
    154159
Note: See TracChangeset for help on using the changeset viewer.