Fix alignment issue of ContiguousContainer

third_party/WebKit/Source/platform/graphics/ContiguousContainer.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/ContiguousContainer.h"
 
 #include "wtf/Allocator.h"
 #include "wtf/ContainerAnnotations.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/allocator/PartitionAlloc.h"
 #include "wtf/allocator/Partitions.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 // Default number of max-sized elements to allocate space for, if there is no
 // initial buffer.
 static const unsigned kDefaultInitialBufferSize = 32;
 
+static inline char* alignAddress(char* address, unsigned log2Alignment)
+{
+    char* aligned = reinterpret_cast<char*>(
+        (((reinterpret_cast<size_t>(address) - 1) >> log2Alignment) + 1) << log2Alignment);

[jbroman, 2016/07/04 19:21:35]

why size_t and not uintptr_t?

+    DCHECK_EQ(0u, reinterpret_cast<size_t>(aligned) % (1 << log2Alignment));
+    DCHECK(aligned >= address);
+    DCHECK(aligned < address + (1 << log2Alignment));
+    return aligned;
+}
+
 class ContiguousContainerBase::Buffer {
     WTF_MAKE_NONCOPYABLE(Buffer);
     USING_FAST_MALLOC(Buffer);
 public:
     Buffer(size_t bufferSize, const char* typeName)
     {
         m_capacity = WTF::Partitions::bufferActualSize(bufferSize);
         m_begin = m_end = static_cast<char*>(
             WTF::Partitions::bufferMalloc(m_capacity, typeName));
         ANNOTATE_NEW_BUFFER(m_begin, m_capacity, 0);
     }
 
     ~Buffer()
     {
         ANNOTATE_DELETE_BUFFER(m_begin, m_capacity, usedCapacity());
         WTF::Partitions::bufferFree(m_begin);
     }
 
     size_t capacity() const { return m_capacity; }
     size_t usedCapacity() const { return m_end - m_begin; }
-    size_t unusedCapacity() const { return capacity() - usedCapacity(); }
     bool isEmpty() const { return usedCapacity() == 0; }
 
-    void* allocate(size_t objectSize)
+    void* allocate(size_t objectSize, unsigned log2Alignment)
     {
-        ASSERT(unusedCapacity() >= objectSize);
+        char* alignedAddress;
+        if (isEmpty()) {
+            // m_begin's alignment must be suitable for all possible types.
+            DCHECK(m_begin == alignAddress(m_begin, log2Alignment));
+            DCHECK(objectSize <= m_capacity);
+            alignedAddress = m_begin;
+        } else {
+            alignedAddress = alignAddress(m_end, log2Alignment);
+            if (alignedAddress - m_begin + objectSize > m_capacity)
+                return nullptr;
+        }
         ANNOTATE_CHANGE_SIZE(
-            m_begin, m_capacity, usedCapacity(), usedCapacity() + objectSize);
-        void* result = m_end;
-        m_end += objectSize;
-        return result;
+            m_begin, m_capacity, usedCapacity(), usedCapacity() + (alignedAddress - m_end) + objectSize);
+        m_end = alignedAddress + objectSize;
+        return alignedAddress;
     }
 
     void deallocateLastObject(void* object)
     {
         RELEASE_ASSERT(m_begin <= object && object < m_end);
         ANNOTATE_CHANGE_SIZE(
             m_begin, m_capacity, usedCapacity(), static_cast<char*>(object) - m_begin);
         m_end = static_cast<char*>(object);
+        // We may leave a gap between the end of the previous object (which we don't know)
+        // and m_end because of alignment of the deallocated object.

[jbroman, 2016/07/04 19:21:35]

...which seems weird to me.

     }
 
 private:
     // m_begin <= m_end <= m_begin + m_capacity
     char* m_begin;
     char* m_end;
     size_t m_capacity;
 };
 
 ContiguousContainerBase::ContiguousContainerBase(size_t maxObjectSize)
@@ skipping 38 matching lines @@
 {
     return sizeof(*this) + capacityInBytes()
         + m_elements.capacity() * sizeof(m_elements[0]);
 }
 
 void ContiguousContainerBase::reserveInitialCapacity(size_t bufferSize, const char* typeName)
 {
     allocateNewBufferForNextAllocation(bufferSize, typeName);
 }
 
-void* ContiguousContainerBase::allocate(size_t objectSize, const char* typeName)
+void* ContiguousContainerBase::allocate(size_t objectSize, unsigned log2Alignment, const char* typeName)
 {
-    ASSERT(objectSize <= m_maxObjectSize);
+    DCHECK(objectSize <= m_maxObjectSize);
 
-    Buffer* bufferForAlloc = nullptr;
-    if (!m_buffers.isEmpty()) {
-        Buffer* endBuffer = m_buffers[m_endIndex].get();
-        if (endBuffer->unusedCapacity() >= objectSize)
-            bufferForAlloc = endBuffer;
-        else if (m_endIndex + 1 < m_buffers.size())
+    void* element = m_buffers.isEmpty() ? nullptr : m_buffers[m_endIndex]->allocate(objectSize, log2Alignment);
+    if (!element) {
+        Buffer* bufferForAlloc;
+        if (m_endIndex + 1 < m_buffers.size()) {
             bufferForAlloc = m_buffers[++m_endIndex].get();
+        } else {
+            size_t newBufferSize = m_buffers.isEmpty()
+                ? kDefaultInitialBufferSize * m_maxObjectSize
+                : 2 * m_buffers.last()->capacity();
+            bufferForAlloc = allocateNewBufferForNextAllocation(newBufferSize, typeName);
+        }
+        element = bufferForAlloc->allocate(objectSize, log2Alignment);
+        DCHECK(element);
     }
-
-    if (!bufferForAlloc) {
-        size_t newBufferSize = m_buffers.isEmpty()
-            ? kDefaultInitialBufferSize * m_maxObjectSize
-            : 2 * m_buffers.last()->capacity();
-        bufferForAlloc = allocateNewBufferForNextAllocation(newBufferSize, typeName);
-    }
-
-    void* element = bufferForAlloc->allocate(objectSize);
     m_elements.append(element);
     return element;
 }
 
 void ContiguousContainerBase::removeLast()
 {
     void* object = m_elements.last();
     m_elements.removeLast();
 
     Buffer* endBuffer = m_buffers[m_endIndex].get();
@@ skipping 27 matching lines @@
 {
     ASSERT(m_buffers.isEmpty() || m_endIndex == m_buffers.size() - 1);
     std::unique_ptr<Buffer> newBuffer = wrapUnique(new Buffer(bufferSize, typeName));
     Buffer* bufferToReturn = newBuffer.get();
     m_buffers.append(std::move(newBuffer));
     m_endIndex = m_buffers.size() - 1;
     return bufferToReturn;
 }
 
 } // namespace blink