Changeset 16622 in webkit for trunk/JavaScriptCore/wtf/Vector.h

Timestamp:

Sep 28, 2006, 2:07:39 PM (19 years ago)

Author:

darin

Message:

JavaScriptCore:

Reviewed by Alice.

• support for change that should fix <rdar://problem/4733044> REGRESSION: XML iBench shows 10% perf. regression (copying strings while decoding)

• wtf/Vector.h: Changed VectorBuffer so that the general case contains an instance of the 0 case, since deriving from it was violating the Liskov Substitution Principle. (WTF::VectorBuffer::releaseBuffer): Added. Releases the buffer so it can be adopted by another data structure that uses the FastMalloc.h allocator. Returns 0 if the internal buffer was being used. (WTF::Vector::releaseBuffer): Added. Releases the buffer as above or creates a new one in the case where the internal buffer was being used.

WebCore:

Reviewed by Alice.

• change that should fix <rdar://problem/4733044> REGRESSION: XML iBench shows 10% perf. regression (copying strings while decoding)

Use Vector<UChar> instead of String when building up the decoded string in
the ICU and Mac decoders. Using String leads to O(n^{2) behavior because
String grows the buffer every single time that append is called. Using
Vector::append instead of String::append also avoids constructing a string
each time just to append and a questionable copy that is done inside the
String::append function which also contributed to the slowness.}

• platform/PlatformString.h:
• platform/String.cpp: (WebCore::String::adopt): Added. Makes a String from a Vector<UChar>, adopting the buffer from the vector to avoid copying and memory allocation.
• platform/StringImpl.h:
• platform/StringImpl.cpp: (WebCore::StringImpl::adopt): Ditto.

• platform/StreamingTextDecoder.h:
• platform/StreamingTextDecoder.cpp: (WebCore::TextCodec::appendOmittingBOM): Change to use a Vector<UChar> instead of a String, since vectors have better resizing performance (they store a separate capacity).

• platform/StreamingTextDecoderICU.cpp: (WebCore::TextCodecICU::decode):
• platform/mac/StreamingTextDecoderMac.cpp: (WebCore::TextCodecMac::decode): Change to use Vector<UChar> instead of String and then create a string at the end of the process using the new adopt function.

File:

• trunk/JavaScriptCore/wtf/Vector.h (modified) (8 diffs)

trunk/JavaScriptCore/wtf/Vector.h

@@ -219 +219 @@
 
     template<typename T>
-    class VectorBuffer<T, 0> 
-    {
+    class VectorBuffer<T, 0> {
     public:
         VectorBuffer()
+            : m_buffer(0), m_capacity(0)
+        {
+        }
+        
+        VectorBuffer(size_t capacity)
+#if !ASSERT_DISABLED
             : m_capacity(0)
-            , m_buffer(0)
-        {
-        }
-        
-        VectorBuffer(size_t capacity)
-            : m_capacity(0)
+#endif
         {
             allocateBuffer(capacity);
@@ -239 +239 @@
         }
         
-        void deallocateBuffer(T* buffer)
+        static void deallocateBuffer(T* buffer)
         {
             fastFree(buffer);
@@ -250 +250 @@
             if (newCapacity > std::numeric_limits<size_t>::max() / sizeof(T))
                 abort();
-            m_buffer = reinterpret_cast<T*>(fastMalloc(newCapacity * sizeof(T)));
+            m_buffer = static_cast<T*>(fastMalloc(newCapacity * sizeof(T)));
         }
 
@@ -257 +257 @@
         size_t capacity() const { return m_capacity; }
 
+        T* releaseBuffer()
+        {
+            T* buffer = m_buffer;
+            m_buffer = 0;
+            m_capacity = 0;
+            return buffer;
+        }
+
     protected:
         VectorBuffer(T* buffer, size_t capacity)
-            : m_capacity(capacity)
-            , m_buffer(buffer)
-        {
-        }
-
+            : m_buffer(buffer), m_capacity(capacity)
+        {
+        }
+
+        T* m_buffer;
+
+    private:
         size_t m_capacity;
-        T *m_buffer;
-    };
-
-    template<typename T, size_t inlineCapacity>
-    class VectorBuffer : public VectorBuffer<T, 0> {
+    };
+
+    template<typename T, size_t inlineCapacity>
+    class VectorBuffer : private VectorBuffer<T, 0> {
     private:
         typedef VectorBuffer<T, 0> BaseBuffer;
     public:
-        VectorBuffer() 
+        VectorBuffer()
             : BaseBuffer(inlineBuffer(), inlineCapacity)
         {
@@ -282 +291 @@
         {
             if (capacity > inlineCapacity)
-                BaseBuffer::allocateBuffer(capacity);
+                allocateBuffer(capacity);
         }
 
         ~VectorBuffer()
         {
-            if (BaseBuffer::buffer() == inlineBuffer())
+            if (buffer() == inlineBuffer())
                 BaseBuffer::m_buffer = 0;
         }
@@ -297 +306 @@
         }
 
+        using BaseBuffer::allocateBuffer;
+
+        using BaseBuffer::buffer;
+        using BaseBuffer::capacity;
+
+        T* releaseBuffer()
+        {
+            if (buffer() == inlineBuffer())
+                return 0;
+            return BaseBuffer::releaseBuffer();
+        }
+
     private:
         static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
-        T *inlineBuffer() { return reinterpret_cast<T *>(&m_inlineBuffer); }
+        T* inlineBuffer() { return reinterpret_cast<T*>(&m_inlineBuffer); }
+
         char m_inlineBuffer[m_inlineBufferSize];
     };
@@ -409 +431 @@
         void fill(const T& val) { fill(val, size()); }
 
+        T* releaseBuffer();
+
     private:
         void expandCapacity(size_t newMinCapacity);
@@ -598 +622 @@
 
     template<typename T, size_t inlineCapacity>
+    T* Vector<T, inlineCapacity>::releaseBuffer()
+    {
+        T* buffer = m_impl.releaseBuffer();
+        if (!buffer && m_size) {
+            // If the vector had some data, but no buffer to release,
+            // that means it was using the inline buffer. In that case,
+            // we create a brand new buffer so the caller always gets one.
+            size_t bytes = m_size * sizeof(T);
+            buffer = static_cast<T*>(fastMalloc(bytes));
+            memcpy(buffer, data(), bytes);
+        }
+        m_size = 0;
+        return buffer;
+    }
+
+    template<typename T, size_t inlineCapacity>
     void deleteAllValues(const Vector<T, inlineCapacity>& collection)
     {