Changeset 44145 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
May 25, 2009, 9:21:32 PM (16 years ago)
Author:
[email protected]
Message:

JavaScriptCore:

2009-05-25 David Levin <​[email protected]>

Reviewed by Maciej Stachowiak and Oliver Hunt.

​https://bugs.webkit.org/show_bug.cgi?id=25126
Allow the buffer underlying UString to be shared.

In order to not grow the underlying size of any structure,
there is a union in the Rep string which holds

+ m_sharedBuffer -- a pointer to the shared ref counted buffer

if the class is BaseString and the buffer is being shared OR

+ m_baseString -- the BaseString if the class is only UString::Rep

but not a UString::BaseString

Ideally, m_sharedBuffer would be a RefPtr, but it cannot be because
it is in a union.

No change in sunspider perf.

  • JavaScriptCore.vcproj/WTF/WTF.vcproj:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • runtime/UString.cpp: (JSC::UString::Rep::share): (JSC::UString::Rep::destroy): (JSC::UString::BaseString::sharedBuffer): (JSC::UString::BaseString::setSharedBuffer): (JSC::UString::BaseString::slowIsBufferReadOnly): (JSC::expandCapacity): (JSC::UString::Rep::reserveCapacity): (JSC::UString::expandPreCapacity): (JSC::concatenate): (JSC::UString::append):
  • runtime/UString.h: (JSC::UString::Rep::Rep): (JSC::UString::Rep::): (JSC::UString::BaseString::isShared): (JSC::UString::BaseString::isBufferReadOnly): (JSC::UString::Rep::baseString):
  • wtf/CrossThreadRefCounted.h: (WTF::CrossThreadRefCounted::isShared):
  • wtf/OwnFastMallocPtr.h: Added. (WTF::OwnFastMallocPtr::OwnFastMallocPtr): (WTF::OwnFastMallocPtr::~OwnFastMallocPtr): (WTF::OwnFastMallocPtr::get): (WTF::OwnFastMallocPtr::release):

JavaScriptGlue:

2009-05-25 David Levin <​[email protected]>

Reviewed by Maciej Stachowiak and Oliver Hunt.

​https://bugs.webkit.org/show_bug.cgi?id=25126

Added forwarding headers.

  • ForwardingHeaders/wtf/CrossThreadRefCounted.h: Added.
  • ForwardingHeaders/wtf/OwnFastMallocPtr.h: Added.

WebCore:

2009-05-25 David Levin <​[email protected]>

Reviewed by Maciej Stachowiak and Oliver Hunt.

Added forwarding headers.

  • ForwardingHeaders/wtf/CrossThreadRefCounted.h: Added.
  • ForwardingHeaders/wtf/OwnFastMallocPtr.h: Added.
Location:
trunk/JavaScriptCore
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r44143 r44145  
     12009-05-25  David Levin  <[email protected]>
     2
     3        Reviewed by Maciej Stachowiak and Oliver Hunt.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=25126
     6        Allow the buffer underlying UString to be shared.
     7
     8        In order to not grow the underlying size of any structure,
     9        there is a union in the Rep string which holds
     10         + m_sharedBuffer -- a pointer to the shared ref counted buffer
     11           if the class is BaseString and the buffer is being shared OR
     12         + m_baseString -- the BaseString if the class is only UString::Rep
     13           but not a UString::BaseString
     14
     15        Ideally, m_sharedBuffer would be a RefPtr, but it cannot be because
     16        it is in a union.
     17
     18        No change in sunspider perf.
     19
     20        * JavaScriptCore.vcproj/WTF/WTF.vcproj:
     21        * JavaScriptCore.xcodeproj/project.pbxproj:
     22        * runtime/UString.cpp:
     23        (JSC::UString::Rep::share):
     24        (JSC::UString::Rep::destroy):
     25        (JSC::UString::BaseString::sharedBuffer):
     26        (JSC::UString::BaseString::setSharedBuffer):
     27        (JSC::UString::BaseString::slowIsBufferReadOnly):
     28        (JSC::expandCapacity):
     29        (JSC::UString::Rep::reserveCapacity):
     30        (JSC::UString::expandPreCapacity):
     31        (JSC::concatenate):
     32        (JSC::UString::append):
     33        * runtime/UString.h:
     34        (JSC::UString::Rep::Rep):
     35        (JSC::UString::Rep::):
     36        (JSC::UString::BaseString::isShared):
     37        (JSC::UString::BaseString::isBufferReadOnly):
     38        (JSC::UString::Rep::baseString):
     39        * wtf/CrossThreadRefCounted.h:
     40        (WTF::CrossThreadRefCounted::isShared):
     41        * wtf/OwnFastMallocPtr.h: Added.
     42        (WTF::OwnFastMallocPtr::OwnFastMallocPtr):
     43        (WTF::OwnFastMallocPtr::~OwnFastMallocPtr):
     44        (WTF::OwnFastMallocPtr::get):
     45        (WTF::OwnFastMallocPtr::release):
     46
    1472009-05-25  Oliver Hunt  <[email protected]>
    248

  • trunk/JavaScriptCore/JavaScriptCore.vcproj/WTF/WTF.vcproj

    r44095 r44145  
    222222                </File>
    223223                <File
     224                        RelativePath="..\..\wtf\CrossThreadRefCounted.h"
     225                        >
     226                </File>
     227                <File
    224228                        RelativePath="..\..\wtf\CurrentTime.cpp"
    225229                        >
    … …  
    331335                <File
    332336                        RelativePath="..\..\wtf\OwnArrayPtr.h"
     337                        >
     338                </File>
     339                <File
     340                        RelativePath="..\..\wtf\OwnFastMallocPtr.h"
    333341                        >
    334342                </File>

  • trunk/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r44095 r44145  
    4343                0B330C270F38C62300692DE3 /* TypeTraits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0B330C260F38C62300692DE3 /* TypeTraits.cpp */; };
    4444                0B4D7E630F319AC800AD7E58 /* TypeTraits.h in Headers */ = {isa = PBXBuildFile; fileRef = 0B4D7E620F319AC800AD7E58 /* TypeTraits.h */; settings = {ATTRIBUTES = (Private, ); }; };
     45                0BDFFAE00FC6192900D69EF4 /* CrossThreadRefCounted.h in Headers */ = {isa = PBXBuildFile; fileRef = 0BDFFAD40FC6171000D69EF4 /* CrossThreadRefCounted.h */; settings = {ATTRIBUTES = (Private, ); }; };
     46                0BDFFAE10FC6193100D69EF4 /* OwnFastMallocPtr.h in Headers */ = {isa = PBXBuildFile; fileRef = 0BDFFAD10FC616EC00D69EF4 /* OwnFastMallocPtr.h */; settings = {ATTRIBUTES = (Private, ); }; };
    4547                140B7D1D0DC69AF7009C42B8 /* JSActivation.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 14DA818F0D99FD2000B0A4FB /* JSActivation.cpp */; };
    4648                140D17D70E8AD4A9000CD17D /* JSBasePrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 140D17D60E8AD4A9000CD17D /* JSBasePrivate.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    456458                0B330C260F38C62300692DE3 /* TypeTraits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TypeTraits.cpp; sourceTree = "<group>"; };
    457459                0B4D7E620F319AC800AD7E58 /* TypeTraits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeTraits.h; sourceTree = "<group>"; };
     460                0BDFFAD10FC616EC00D69EF4 /* OwnFastMallocPtr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OwnFastMallocPtr.h; sourceTree = "<group>"; };
     461                0BDFFAD40FC6171000D69EF4 /* CrossThreadRefCounted.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CrossThreadRefCounted.h; sourceTree = "<group>"; };
    458462                140D17D60E8AD4A9000CD17D /* JSBasePrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSBasePrivate.h; sourceTree = "<group>"; };
    459463                141211020A48780900480255 /* minidom.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = minidom.c; path = tests/minidom.c; sourceTree = "<group>"; };
    … …  
    11621166                                A7A1F7AA0F252B3C00E184E2 /* ByteArray.cpp */,
    11631167                                A7A1F7AB0F252B3C00E184E2 /* ByteArray.h */,
     1168                                0BDFFAD40FC6171000D69EF4 /* CrossThreadRefCounted.h */,
    11641169                                180B9AEF0F16C569009BDBC5 /* CurrentTime.cpp */,
    11651170                                180B9AF00F16C569009BDBC5 /* CurrentTime.h */,
    … …  
    11931198                                C0A2723F0E509F1E00E96E15 /* NotFound.h */,
    11941199                                9303F5A409911A5800AD71B8 /* OwnArrayPtr.h */,
     1200                                0BDFFAD10FC616EC00D69EF4 /* OwnFastMallocPtr.h */,
    11951201                                9303F567099118FA00AD71B8 /* OwnPtr.h */,
    11961202                                440B7AED0FAF7FCB0073323E /* OwnPtrCommon.h */,
    … …  
    18301836                                93052C350FB792190048FDC3 /* ParserArena.h in Headers */,
    18311837                                960626960FB8EC02009798AB /* JITStubCall.h in Headers */,
     1838                                0BDFFAE00FC6192900D69EF4 /* CrossThreadRefCounted.h in Headers */,
     1839                                0BDFFAE10FC6193100D69EF4 /* OwnFastMallocPtr.h in Headers */,
    18321840                        );
    18331841                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/JavaScriptCore/runtime/UString.cpp

    r43856 r44145  
    11/*
    22 *  Copyright (C) 1999-2000 Harri Porten ([email protected])
    3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
     3 *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
    44 *  Copyright (C) 2007 Cameron Zwarich ([email protected])
    5  *  Copyright (c) 2009, Google Inc. All rights reserved.
     5 *  Copyright (C) 2009 Google Inc. All rights reserved.
    66 *
    77 *  This library is free software; you can redistribute it and/or
    … …  
    233233}
    234234
     235PassRefPtr<UString::Rep> UString::Rep::share(UChar* string, int length, PassRefPtr<UString::SharedUChar> sharedBuffer)
     236{
     237    PassRefPtr<UString::Rep> rep = create(string, length);
     238    rep->baseString()->setSharedBuffer(sharedBuffer);
     239    rep->checkConsistency();
     240    return rep;
     241}
     242
    235243void UString::Rep::destroy()
    236244{
    … …  
    242250        if (identifierTable())
    243251            Identifier::remove(this);
     252
    244253        UString::BaseString* base = baseString();
    245         if (base == this)
    246             fastFree(base->buf);
    247         else
     254        if (base == this) {
     255            if (m_sharedBuffer)
     256                m_sharedBuffer->deref();
     257            else
     258                fastFree(base->buf);
     259        } else
    248260            base->deref();
    249261
    … …  
    368380}
    369381#endif
     382
     383UString::SharedUChar* UString::BaseString::sharedBuffer()
     384{
     385    // Don't share empty, null and 1 character strings from SmallStrings.
     386    if (len <= 1)
     387        return 0;
     388
     389    if (!m_sharedBuffer)
     390        setSharedBuffer(SharedUChar::create(new OwnFastMallocPtr<UChar>(buf)));
     391    return m_sharedBuffer;
     392}
     393
     394void UString::BaseString::setSharedBuffer(PassRefPtr<UString::SharedUChar> sharedBuffer)
     395{
     396    // The manual steps below are because m_sharedBuffer can't be a RefPtr. m_sharedBuffer
     397    // is in a union with another variable to avoid making BaseString any larger.
     398    if (m_sharedBuffer)
     399        m_sharedBuffer->deref();
     400    m_sharedBuffer = sharedBuffer.releaseRef();
     401}
     402
     403bool UString::BaseString::slowIsBufferReadOnly()
     404{
     405    // The buffer may not be modified as soon as the underlying data has been shared with another class.
     406    if (m_sharedBuffer->isShared())
     407        return true;
     408
     409    // At this point, we know it that the underlying buffer isn't shared outside of this base class,
     410    // so get rid of m_sharedBuffer.
     411    OwnPtr<OwnFastMallocPtr<UChar> > mallocPtr(m_sharedBuffer->release());
     412    UChar* unsharedBuf = const_cast<UChar*>(mallocPtr->release());
     413    setSharedBuffer(0);
     414    preCapacity += (buf - unsharedBuf);
     415    buf = unsharedBuf;
     416    return false;
     417}
    370418
    371419// Put these early so they can be inlined.
    … …  
    418466{
    419467    rep->checkConsistency();
     468    ASSERT(!rep->baseString()->isBufferReadOnly());
    420469
    421470    UString::BaseString* base = rep->baseString();
    … …  
    443492    // If the BaseString is shared with another string that is using more capacity than this
    444493    // string is, then growing the buffer won't help.
    445     if (!m_baseString->buf || !m_baseString->capacity || (offset + len) != m_baseString->usedCapacity)
     494    // If the BaseString's buffer is readonly, then it isn't allowed to grow.
     495    UString::BaseString* base = baseString();
     496    if (!base->buf || !base->capacity || (offset + len) != base->usedCapacity || base->isBufferReadOnly())
    446497        return false;
    447498   
    448499    // If there is already sufficient capacity, no need to grow!
    449     if (capacity <= m_baseString->capacity)
     500    if (capacity <= base->capacity)
    450501        return true;
    451502
    452503    checkConsistency();
    453504
    454     size_t newCapacity = expandedSize(capacity, m_baseString->preCapacity);
    455     UChar* oldBuf = m_baseString->buf;
    456     m_baseString->buf = reallocChars(m_baseString->buf, newCapacity);
    457     if (!m_baseString->buf) {
    458         m_baseString->buf = oldBuf;
     505    size_t newCapacity = expandedSize(capacity, base->preCapacity);
     506    UChar* oldBuf = base->buf;
     507    base->buf = reallocChars(base->buf, newCapacity);
     508    if (!base->buf) {
     509        base->buf = oldBuf;
    459510        return false;
    460511    }
    461     m_baseString->capacity = newCapacity - m_baseString->preCapacity;
     512    base->capacity = newCapacity - base->preCapacity;
    462513
    463514    checkConsistency();
    … …  
    474525{
    475526    m_rep->checkConsistency();
     527    ASSERT(!m_rep->baseString()->isBufferReadOnly());
    476528
    477529    BaseString* base = m_rep->baseString();
    … …  
    586638            rep->_hash = 0;
    587639        }
    588     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
     640    } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize && !base->isBufferReadOnly()) {
    589641        // this reaches the end of the buffer - extend it if it's long enough to append to
    590642        if (!expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length)))
    … …  
    595647        }
    596648    } else {
    597         // this is shared with someone using more capacity, gotta make a whole new string
     649        // This is shared in some way that prevents us from modifying base, so we must make a whole new string.
    598650        size_t newCapacity = expandedSize(length, 0);
    599651        UChar* d = allocChars(newCapacity);
    … …  
    641693            rep->_hash = 0;
    642694        }
    643     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
     695    } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize && !base->isBufferReadOnly()) {
    644696        // this string reaches the end of the buffer - extend it
    645697        expandCapacity(rep.get(), newCapacityWithOverflowCheck(thisOffset, length));
    … …  
    651703        }
    652704    } else {
    653         // this is shared with someone using more capacity, gotta make a whole new string
     705        // This is shared in some way that prevents us from modifying base, so we must make a whole new string.
    654706        size_t newCapacity = expandedSize(length, 0);
    655707        UChar* d = allocChars(newCapacity);
    … …  
    682734
    683735    UString::BaseString* aBase = a->baseString();
    684     if (bSize == 1 && aOffset + aSize == aBase->usedCapacity && aOffset + aSize < aBase->capacity) {
     736    if (bSize == 1 && aOffset + aSize == aBase->usedCapacity && aOffset + aSize < aBase->capacity && !aBase->isBufferReadOnly()) {
    685737        // b is a single character (common fast case)
    686738        ++aBase->usedCapacity;
    … …  
    701753    UString::BaseString* bBase = b->baseString();
    702754    if (aOffset + aSize == aBase->usedCapacity && aSize >= minShareSize && 4 * aSize >= bSize
    703         && (-bOffset != bBase->usedPreCapacity || aSize >= bSize)) {
     755        && (-bOffset != bBase->usedPreCapacity || aSize >= bSize) && !aBase->isBufferReadOnly()) {
    704756        // - a reaches the end of its buffer so it qualifies for shared append
    705757        // - also, it's at least a quarter the length of b - appending to a much shorter
    … …  
    721773    }
    722774
    723     if (-bOffset == bBase->usedPreCapacity && bSize >= minShareSize && 4 * bSize >= aSize) {
     775    if (-bOffset == bBase->usedPreCapacity && bSize >= minShareSize && 4 * bSize >= aSize && !bBase->isBufferReadOnly()) {
    724776        // - b reaches the beginning of its buffer so it qualifies for shared prepend
    725777        // - also, it's at least a quarter the length of a - prepending to a much shorter
    … …  
    10841136            m_rep->_hash = 0;
    10851137        }
    1086     } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize) {
     1138    } else if (thisOffset + thisSize == base->usedCapacity && thisSize >= minShareSize && !base->isBufferReadOnly()) {
    10871139        // this reaches the end of the buffer - extend it if it's long enough to append to
    10881140        expandCapacity(newCapacityWithOverflowCheck(thisOffset, length));
    … …  
    10921144        }
    10931145    } else {
    1094         // this is shared with someone using more capacity, gotta make a whole new string
     1146        // This is shared in some way that prevents us from modifying base, so we must make a whole new string.
    10951147        size_t newCapacity = expandedSize(length, 0);
    10961148        UChar* d = allocChars(newCapacity);
    … …  
    11641216            m_rep->_hash = 0;
    11651217        }
    1166     } else if (thisOffset + length == base->usedCapacity && length >= minShareSize) {
     1218    } else if (thisOffset + length == base->usedCapacity && length >= minShareSize && !base->isBufferReadOnly()) {
    11671219        // this reaches the end of the string - extend it and share
    11681220        expandCapacity(newCapacityWithOverflowCheck(thisOffset, length, true));
    … …  
    11731225        }
    11741226    } else {
    1175         // this is shared with someone using more capacity, gotta make a whole new string
     1227        // This is shared in some way that prevents us from modifying base, so we must make a whole new string.
    11761228        size_t newCapacity = expandedSize(length + 1, 0);
    11771229        UChar* d = allocChars(newCapacity);

  • trunk/JavaScriptCore/runtime/UString.h

    r43856 r44145  
    22 *  Copyright (C) 1999-2000 Harri Porten ([email protected])
    33 *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
    4  *  Copyright (c) 2009, Google Inc. All rights reserved.
     4 *  Copyright (C) 2009 Google Inc. All rights reserved.
    55 *
    66 *  This library is free software; you can redistribute it and/or
    … …  
    2828#include <string.h>
    2929#include <wtf/Assertions.h>
     30#include <wtf/CrossThreadRefCounted.h>
     31#include <wtf/OwnFastMallocPtr.h>
    3032#include <wtf/PassRefPtr.h>
    3133#include <wtf/PtrAndFlags.h>
    … …  
    7678
    7779    public:
     80        typedef CrossThreadRefCounted<OwnFastMallocPtr<UChar> > SharedUChar;
    7881        struct BaseString;
    7982        struct Rep : Noncopyable {
    … …  
    102105            static PassRefPtr<Rep> createFromUTF8(const char*);
    103106
     107            // Uses SharedUChar to have joint ownership over the UChar*.
     108            static PassRefPtr<Rep> share(UChar*, int, PassRefPtr<SharedUChar>);
     109
    104110            void destroy();
    105111
    … …  
    146152
    147153        protected:
    148             // constructor for use by BaseString subclass; they are their own bases
     154            // Constructor for use by BaseString subclass; they use the union with m_baseString for another purpose.
    149155            Rep(int length)
    150156                : offset(0)
    … …  
    152158                , rc(1)
    153159                , _hash(0)
    154                 , m_baseString(static_cast<BaseString*>(this))
     160                , m_baseString(0)
    155161            {
    156162            }
    … …  
    166172            }
    167173
    168 
    169             BaseString* m_baseString;
     174            union {
     175                // If !baseIsSelf()
     176                BaseString* m_baseString;
     177                // If baseIsSelf()
     178                SharedUChar* m_sharedBuffer;
     179            };
    170180
    171181        private:
    … …  
    181191
    182192        struct BaseString : public Rep {
    183             bool isShared() { return rc != 1; }
     193            bool isShared() { return rc != 1 || isBufferReadOnly(); }
     194            void setSharedBuffer(PassRefPtr<SharedUChar>);
     195            SharedUChar* sharedBuffer();
     196
     197            bool isBufferReadOnly()
     198            {
     199                if (!m_sharedBuffer)
     200                    return false;
     201                return slowIsBufferReadOnly();
     202            }
    184203
    185204            // potentially shared data.
    … …  
    205224                checkConsistency();
    206225            }
     226
     227            bool slowIsBufferReadOnly();
    207228
    208229            friend struct Rep;
    … …  
    454475    inline UString::BaseString* UString::Rep::baseString()
    455476    {
    456         return m_baseString;
     477        return !baseIsSelf() ? m_baseString : reinterpret_cast<BaseString*>(this) ;
    457478    }
    458479
    459480    inline const UString::BaseString* UString::Rep::baseString() const
    460481    {
    461         return m_baseString;
     482        return const_cast<Rep*>(this)->baseString();
    462483    }
    463484

  • trunk/JavaScriptCore/wtf/CrossThreadRefCounted.h

    r43663 r44145  
    3636#include <wtf/RefCounted.h>
    3737#include <wtf/Threading.h>
    38 #include <wtf/TypeTraits.h>
    3938
    4039namespace WTF {
    … …  
    6665        void deref();
    6766        T* release();
     67
     68        bool isShared() const
     69        {
     70            return !m_refCounter.hasOneRef() || (m_threadSafeRefCounter && !m_threadSafeRefCounter->hasOneRef());
     71        }
    6872
    6973#ifndef NDEBUG
Note: See TracChangeset for help on using the changeset viewer.