code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/PODArena.h

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef PODArena_h
  27 #define PODArena_h
  28
  29 #include <stdint.h>
  30 #include <wtf/Assertions.h>
  31 #include <wtf/FastMalloc.h>
  32 #include <wtf/Noncopyable.h>
  33 #include <wtf/OwnPtr.h>
  34 #include <wtf/PassOwnPtr.h>
  35 #include <wtf/RefCounted.h>
  36 #include <wtf/Vector.h>
  37
  38 namespace WebCore {
  39
  40 // An arena which allocates only Plain Old Data (POD), or classes and
  41 // structs bottoming out in Plain Old Data. NOTE: the constructors of
  42 // the objects allocated in this arena are called, but _not_ their
  43 // destructors.
  44
  45 class PODArena : public RefCounted<PODArena> {
  46 public:
  47     // The arena is configured with an allocator, which is responsible
  48     // for allocating and freeing chunks of memory at a time.
  49     class Allocator : public RefCounted<Allocator> {
  50     public:
  51         virtual void* allocate(size_t size) = 0;
  52         virtual void free(void* ptr) = 0;
  53     protected:
  54         virtual ~Allocator() { }
  55         friend class WTF::RefCounted<Allocator>;
  56     };
  57
  58     // The Arena's default allocator, which uses fastMalloc and
  59     // fastFree to allocate chunks of storage.
  60     class FastMallocAllocator : public Allocator {
  61     public:
  62         static PassRefPtr<FastMallocAllocator> create()
  63         {
  64             return adoptRef(new FastMallocAllocator);
  65         }
  66
  67         virtual void* allocate(size_t size) { return fastMalloc(size); }
  68         virtual void free(void* ptr) { fastFree(ptr); }
  69
  70     protected:
  71         FastMallocAllocator() { }
  72     };
  73
  74     // Creates a new PODArena configured with a FastMallocAllocator.
  75     static PassRefPtr<PODArena> create()
  76     {
  77         return adoptRef(new PODArena);
  78     }
  79
  80     // Creates a new PODArena configured with the given Allocator.
  81     static PassRefPtr<PODArena> create(PassRefPtr<Allocator> allocator)
  82     {
  83         return adoptRef(new PODArena(allocator));
  84     }
  85
  86     // Allocates an object from the arena.
  87     template<class T> T* allocateObject()
  88     {
  89         void* ptr = allocateBase<T>();
  90         if (ptr) {
  91             // Use placement operator new to allocate a T at this location.
  92             new(ptr) T();
  93         }
  94         return static_cast<T*>(ptr);
  95     }
  96
  97     // Allocates an object from the arena, calling a single-argument constructor.
  98     template<class T, class Argument1Type> T* allocateObject(const Argument1Type& argument1)
  99     {
 100         void* ptr = allocateBase<T>();
 101         if (ptr) {
 102             // Use placement operator new to allocate a T at this location.
 103             new(ptr) T(argument1);
 104         }
 105         return static_cast<T*>(ptr);
 106     }
 107
 108     // The initial size of allocated chunks; increases as necessary to
 109     // satisfy large allocations. Mainly public for unit tests.
 110     enum {
 111         DefaultChunkSize = 16384
 112     };
 113
 114 protected:
 115     ~PODArena() { }
 116     friend class WTF::RefCounted<PODArena>;
 117
 118 private:
 119     PODArena()
 120         : m_allocator(FastMallocAllocator::create())
 121         , m_current(0)
 122         , m_currentChunkSize(DefaultChunkSize) { }
 123
 124     explicit PODArena(PassRefPtr<Allocator> allocator)
 125         : m_allocator(allocator)
 126         , m_current(0)
 127         , m_currentChunkSize(DefaultChunkSize) { }
 128
 129     // Returns the alignment requirement for classes and structs on the
 130     // current platform.
 131     template <class T> static size_t minAlignment()
 132     {
 133         return WTF_ALIGN_OF(T);
 134     }
 135
 136     template<class T> void* allocateBase()
 137     {
 138         void* ptr = 0;
 139         size_t roundedSize = roundUp(sizeof(T), minAlignment<T>());
 140         if (m_current)
 141             ptr = m_current->allocate(roundedSize);
 142
 143         if (!ptr) {
 144             if (roundedSize > m_currentChunkSize)
 145                 m_currentChunkSize = roundedSize;
 146             m_chunks.append(adoptPtr(new Chunk(m_allocator.get(), m_currentChunkSize)));
 147             m_current = m_chunks.last().get();
 148             ptr = m_current->allocate(roundedSize);
 149         }
 150         return ptr;
 151     }
 152
 153     // Rounds up the given allocation size to the specified alignment.
 154     size_t roundUp(size_t size, size_t alignment)
 155     {
 156         ASSERT(!(alignment % 2));
 157         return (size + alignment - 1) & ~(alignment - 1);
 158     }
 159
 160     // Manages a chunk of memory and individual allocations out of it.
 161     class Chunk {
 162         WTF_MAKE_NONCOPYABLE(Chunk);
 163     public:
 164         // Allocates a block of memory of the given size from the passed
 165         // Allocator.
 166         Chunk(Allocator* allocator, size_t size)
 167             : m_allocator(allocator)
 168             , m_size(size)
 169             , m_currentOffset(0)
 170         {
 171             m_base = static_cast<uint8_t*>(m_allocator->allocate(size));
 172         }
 173
 174         // Frees the memory allocated from the Allocator in the
 175         // constructor.
 176         ~Chunk()
 177         {
 178             m_allocator->free(m_base);
 179         }
 180
 181         // Returns a pointer to "size" bytes of storage, or 0 if this
 182         // Chunk could not satisfy the allocation.
 183         void* allocate(size_t size)
 184         {
 185             // Check for overflow
 186             if (m_currentOffset + size < m_currentOffset)
 187                 return 0;
 188
 189             if (m_currentOffset + size > m_size)
 190                 return 0;
 191
 192             void* result = m_base + m_currentOffset;
 193             m_currentOffset += size;
 194             return result;
 195         }
 196
 197     private:
 198         Allocator* m_allocator;
 199         uint8_t* m_base;
 200         size_t m_size;
 201         size_t m_currentOffset;
 202     };
 203
 204     RefPtr<Allocator> m_allocator;
 205     Chunk* m_current;
 206     size_t m_currentChunkSize;
 207     Vector<OwnPtr<Chunk> > m_chunks;
 208 };
 209
 210 } // namespace WebCore
 211
 212 #endif // PODArena_h