Get rid of the inline member data in Object

Instead allocate a MemberData at the same time as the
object if required. Turns out this is faster now,
and significantly simplifies some of our internal logic
to access member properties.

In addition, we can properly setup the inline member size
to use the full extent of the memory reserved by the
memory manager. This avoid some needless reallocations of
MemberData objects.

Change-Id: I36daeeaf6df16f2268103662fc78d600b4058ef8
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

6 files changed, 41 insertions, 56 deletions

diff --git a/src/qml/jsruntime/qv4internalclass.cpp b/src/qml/jsruntime/qv4internalclass.cpp
index d17da9af0c..bac71b4537 100644
--- a/src/qml/jsruntime/qv4internalclass.cpp
+++ b/src/qml/jsruntime/qv4internalclass.cpp
@@ -128,48 +128,22 @@ InternalClass::InternalClass(const QV4::InternalClass &other)
 
 static void insertHoleIntoPropertyData(Object *object, int idx)
 {
-    int inlineSize = object->d()->inlineMemberSize;
     int icSize = object->internalClass()->size;
-    int from = qMax(idx, inlineSize);
+    int from = idx;
     int to = from + 1;
-    if (from < icSize) {
+    if (from < icSize)
         memmove(object->propertyData(to), object->propertyData(from),
                 (icSize - from - 1) * sizeof(Value));
-    }
-    if (from == idx)
-        return;
-    if (inlineSize < icSize)
-        *object->propertyData(inlineSize) = *object->propertyData(inlineSize - 1);
-    from = idx;
-    to = from + 1;
-    if (from < inlineSize - 1) {
-        memmove(object->propertyData(to), object->propertyData(from),
-                (inlineSize - from - 1) * sizeof(Value));
-    }
 }
 
 static void removeFromPropertyData(Object *object, int idx, bool accessor = false)
 {
-    int inlineSize = object->d()->inlineMemberSize;
     int delta = (accessor ? 2 : 1);
     int oldSize = object->internalClass()->size + delta;
     int to = idx;
     int from = to + delta;
-    if (from < inlineSize) {
-        memmove(object->propertyData(to), object->d()->propertyData(from), (inlineSize - from)*sizeof(Value));
-        to = inlineSize - delta;
-        from = inlineSize;
-    }
-    if (to < inlineSize && from < oldSize) {
-        Q_ASSERT(from >= inlineSize);
-        memcpy(object->propertyData(to), object->d()->propertyData(from), (inlineSize - to)*sizeof(Value));
-        to = inlineSize;
-        from = inlineSize + delta;
-    }
-    if (from < oldSize) {
-        Q_ASSERT(to >= inlineSize && from > to);
+    if (from < oldSize)
         memmove(object->propertyData(to), object->d()->propertyData(from), (oldSize - to)*sizeof(Value));
-    }
 }
 
 void InternalClass::changeMember(Object *object, String *string, PropertyAttributes data, uint *index)
diff --git a/src/qml/jsruntime/qv4memberdata.cpp b/src/qml/jsruntime/qv4memberdata.cpp
index d5f75415cc..f2a24f8179 100644
--- a/src/qml/jsruntime/qv4memberdata.cpp
+++ b/src/qml/jsruntime/qv4memberdata.cpp
@@ -56,12 +56,12 @@ Heap::MemberData *MemberData::allocate(ExecutionEngine *e, uint n, Heap::MemberD
 {
     Q_ASSERT(!old || old->size < n);
 
-    uint alloc = sizeof(Heap::MemberData) + (n)*sizeof(Value);
+    size_t alloc = MemoryManager::align(sizeof(Heap::MemberData) + (n - 1)*sizeof(Value));
     Heap::MemberData *m = e->memoryManager->allocManaged<MemberData>(alloc);
     if (old)
-        memcpy(m, old, sizeof(Heap::MemberData) + old->size * sizeof(Value));
+        memcpy(m, old, sizeof(Heap::MemberData) + (old->size - 1)* sizeof(Value));
     else
         m->init();
-    m->size = n;
+    m->size = static_cast<uint>((alloc - sizeof(Heap::MemberData) + sizeof(Value))/sizeof(Value));
     return m;
 }
diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp
index 8acca16dd0..f217e301ac 100644
--- a/src/qml/jsruntime/qv4object.cpp
+++ b/src/qml/jsruntime/qv4object.cpp
@@ -61,9 +61,8 @@ DEFINE_OBJECT_VTABLE(Object);
 void Object::setInternalClass(InternalClass *ic)
 {
     d()->internalClass = ic;
-    if ((ic->size > d()->inlineMemberSize && !d()->memberData) ||
-        (d()->memberData && d()->memberData->size < ic->size - d()->inlineMemberSize))
-        d()->memberData = MemberData::allocate(ic->engine, ic->size - d()->inlineMemberSize, d()->memberData);
+    if (!d()->memberData || (d()->memberData->size < ic->size))
+        d()->memberData = MemberData::allocate(ic->engine, ic->size, d()->memberData);
 }
 
 void Object::getProperty(uint index, Property *p, PropertyAttributes *attrs) const
@@ -213,12 +212,6 @@ void Object::markObjects(Heap::Base *that, ExecutionEngine *e)
 {
     Heap::Object *o = static_cast<Heap::Object *>(that);
 
-    if (o->inlineMemberSize) {
-        Value *v = o->propertyData(0);
-        for (uint i = 0; i < o->inlineMemberSize; ++i)
-            v[i].mark(e);
-    }
-
     if (o->memberData)
         o->memberData->mark(e);
     if (o->arrayData)
diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h
index 6c679deb10..65820911db 100644
--- a/src/qml/jsruntime/qv4object_p.h
+++ b/src/qml/jsruntime/qv4object_p.h
@@ -69,11 +69,9 @@ struct Object : Base {
     void init() { Base::init(); }
     void destroy() { Base::destroy(); }
 
-    const Value *propertyData(uint index) const { if (index < inlineMemberSize) return reinterpret_cast<const Value *>(this) + inlineMemberOffset + index; return memberData->data + index - inlineMemberSize; }
-    Value *propertyData(uint index) { if (index < inlineMemberSize) return reinterpret_cast<Value *>(this) + inlineMemberOffset + index; return memberData->data + index - inlineMemberSize; }
+    const Value *propertyData(uint index) const { return memberData->data + index; }
+    Value *propertyData(uint index) { return memberData->data + index; }
 
-    uint inlineMemberOffset;
-    uint inlineMemberSize;
     InternalClass *internalClass;
     Pointer<Object> prototype;
     Pointer<MemberData> memberData;
diff --git a/src/qml/memory/qv4mm.cpp b/src/qml/memory/qv4mm.cpp
index 4cad197d32..6330ef6038 100644
--- a/src/qml/memory/qv4mm.cpp
+++ b/src/qml/memory/qv4mm.cpp
@@ -627,7 +627,7 @@ Heap::Base *MemoryManager::allocString(std::size_t unmanagedSize)
     if (aggressiveGC)
         runGC();
 
-    const uint stringSize = align(sizeof(Heap::String));
+    const size_t stringSize = align(sizeof(Heap::String));
     unmanagedHeapSize += unmanagedSize;
     bool didGCRun = false;
     if (unmanagedHeapSize > unmanagedHeapSizeGCLimit) {
@@ -680,6 +680,29 @@ Heap::Base *MemoryManager::allocData(std::size_t size)
     return *m;
 }
 
+Heap::Object *MemoryManager::allocObjectWithMemberData(std::size_t size, uint nMembers)
+{
+    Heap::Object *o = static_cast<Heap::Object *>(allocData(size));
+
+    // ### Could optimize this and allocate both in one go through the block allocator
+    if (nMembers) {
+        std::size_t memberSize = align(sizeof(Heap::MemberData) + (nMembers - 1)*sizeof(Value));
+//        qDebug() << "allocating member data for" << o << nMembers << memberSize;
+        Heap::Base *m;
+        if (memberSize > Chunk::DataSize)
+            m = *hugeItemAllocator.allocate(memberSize);
+        else
+            m = *blockAllocator.allocate(memberSize, true);
+        memset(m, 0, memberSize);
+        o->memberData = static_cast<Heap::MemberData *>(m);
+        o->memberData->setVtable(MemberData::staticVTable());
+        o->memberData->size = static_cast<uint>((memberSize - sizeof(Heap::MemberData) + sizeof(Value))/sizeof(Value));
+        o->memberData->init();
+//        qDebug() << "    got" << o->memberData << o->memberData->size;
+    }
+    return o;
+}
+
 static void drainMarkStack(QV4::ExecutionEngine *engine, Value *markBase)
 {
     while (engine->jsStackTop > markBase) {
diff --git a/src/qml/memory/qv4mm_p.h b/src/qml/memory/qv4mm_p.h
index 7517328b37..76017f8148 100644
--- a/src/qml/memory/qv4mm_p.h
+++ b/src/qml/memory/qv4mm_p.h
@@ -224,26 +224,22 @@ public:
     template <typename ObjectType>
     typename ObjectType::Data *allocateObject(InternalClass *ic)
     {
-        const int size = (sizeof(typename ObjectType::Data) + (sizeof(Value) - 1)) & ~(sizeof(Value) - 1);
-        typename ObjectType::Data *o = allocManaged<ObjectType>(size + ic->size*sizeof(Value));
+        Heap::Object *o = allocObjectWithMemberData(align(sizeof(typename ObjectType::Data)), ic->size);
+        o->setVtable(ObjectType::staticVTable());
         o->internalClass = ic;
-        o->inlineMemberSize = ic->size;
-        o->inlineMemberOffset = size/sizeof(Value);
-        return o;
+        return static_cast<typename ObjectType::Data *>(o);
     }
 
     template <typename ObjectType>
     typename ObjectType::Data *allocateObject()
     {
         InternalClass *ic = ObjectType::defaultInternalClass(engine);
-        const int size = (sizeof(typename ObjectType::Data) + (sizeof(Value) - 1)) & ~(sizeof(Value) - 1);
-        typename ObjectType::Data *o = allocManaged<ObjectType>(size + ic->size*sizeof(Value));
+        Heap::Object *o = allocObjectWithMemberData(align(sizeof(typename ObjectType::Data)), ic->size);
+        o->setVtable(ObjectType::staticVTable());
         Object *prototype = ObjectType::defaultPrototype(engine);
         o->internalClass = ic;
         o->prototype = prototype->d();
-        o->inlineMemberSize = ic->size;
-        o->inlineMemberOffset = size/sizeof(Value);
-        return o;
+        return static_cast<typename ObjectType::Data *>(o);
     }
 
     template <typename ManagedType, typename Arg1>
@@ -430,6 +426,7 @@ protected:
     /// expects size to be aligned
     Heap::Base *allocString(std::size_t unmanagedSize);
     Heap::Base *allocData(std::size_t size);
+    Heap::Object *allocObjectWithMemberData(std::size_t size, uint nMembers);
 
 #ifdef DETAILED_MM_STATS
     void willAllocate(std::size_t size);