Optimize very big object expression through big bloom filter

Signed-off-by: Seonghyun Kim <sh8281.kim@samsung.com>

Author: ksh8281

src/interpreter/ByteCode.h

@@ -966,24 +966,30 @@ class CreateObjectPrepare : public ByteCode {
     };
 
     typedef BloomFilter<1024> CreateObjectPropertyFilter;
+    typedef BloomFilter<1024 * 64> CreateObjectBigPropertyFilter;
 
     struct CreateObjectData : public gc {
-        bool m_allPrecomputed;
-        bool m_wasStructureComputed;
-        bool m_canStoreStructureOnCode;
-        bool m_needsToUsePropertyFilterOnIntepreter;
+        bool m_allPrecomputed : 1;
+        bool m_wasStructureComputed : 1;
+        bool m_canStoreStructureOnCode : 1;
+        bool m_needsToUsePropertyFilterOnInterpreter : 1;
+        bool m_needsToUseBigPropertyFilterOnInterpreter : 1;
         VectorWithInlineStorage<6, ObjectStructureItem, GCUtil::gc_malloc_allocator<ObjectStructureItem>> m_properties;
         EncodedValueVector m_values;
         Object* m_target;
         CreateObjectPrepare* m_initCode;
-        Optional<CreateObjectPropertyFilter*> m_filter;
+        union {
+            Optional<CreateObjectPropertyFilter*> m_filter;
+            Optional<CreateObjectBigPropertyFilter*> m_bigFilter;
+        };
         CreateObjectData(bool allPrecomputed, bool wasStructureComputed, bool canStoreStructureOnCode,
-                         bool needsToUsePropertyFilterOnIntepreter,
+                         bool needsToUsePropertyFilterOnInterpreter, bool needsToUseBigPropertyFilterOnInterpreter,
                          size_t reserveSize, Object* target, CreateObjectPrepare* initCode)
             : m_allPrecomputed(allPrecomputed)
             , m_wasStructureComputed(wasStructureComputed)
             , m_canStoreStructureOnCode(canStoreStructureOnCode)
-            , m_needsToUsePropertyFilterOnIntepreter(needsToUsePropertyFilterOnIntepreter)
+            , m_needsToUsePropertyFilterOnInterpreter(needsToUsePropertyFilterOnInterpreter)
+            , m_needsToUseBigPropertyFilterOnInterpreter(needsToUseBigPropertyFilterOnInterpreter)
             , m_target(target)
             , m_initCode(initCode)
         {
@@ -994,11 +1000,13 @@ class CreateObjectPrepare : public ByteCode {
         }
     };
 
-    CreateObjectPrepare(const ByteCodeLOC& loc, const size_t dataRegisterIndex, const size_t objectIndex, bool needsToUseNameFilterOnIntepreter)
+    CreateObjectPrepare(const ByteCodeLOC& loc, const size_t dataRegisterIndex, const size_t objectIndex, bool needsToUseNameFilterOnIntepreter,
+                        bool needsToUseBigPropertyFilterOnInterpreter)
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::Init)
         , m_allPrecomputed(false)
-        , m_needsToUsePropertyFilterOnIntepreter(needsToUseNameFilterOnIntepreter)
+        , m_needsToUsePropertyFilterOnInterpreter(needsToUseNameFilterOnIntepreter)
+        , m_needsToUseBigPropertyFilterOnInterpreter(needsToUseBigPropertyFilterOnInterpreter)
         , m_hasPrecomputedKey(false)
         , m_needsToUpdateFunctionName(false)
         , m_isGetter(false)
@@ -1012,7 +1020,8 @@ class CreateObjectPrepare : public ByteCode {
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::FillKeyValue)
         , m_allPrecomputed(false)
-        , m_needsToUsePropertyFilterOnIntepreter(false)
+        , m_needsToUsePropertyFilterOnInterpreter(false)
+        , m_needsToUseBigPropertyFilterOnInterpreter(false)
         , m_hasPrecomputedKey(hasPreComputedKey)
         , m_needsToUpdateFunctionName(needsToUpdateFunctionName)
         , m_isGetter(false)
@@ -1026,7 +1035,8 @@ class CreateObjectPrepare : public ByteCode {
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::DefineGetterSetter)
         , m_allPrecomputed(false)
-        , m_needsToUsePropertyFilterOnIntepreter(false)
+        , m_needsToUsePropertyFilterOnInterpreter(false)
+        , m_needsToUseBigPropertyFilterOnInterpreter(false)
         , m_hasPrecomputedKey(hasPreComputedKey)
         , m_needsToUpdateFunctionName(false)
         , m_isGetter(isGetter)
@@ -1038,7 +1048,8 @@ class CreateObjectPrepare : public ByteCode {
 
     Stage m_stage : 2;
     bool m_allPrecomputed : 1;
-    bool m_needsToUsePropertyFilterOnIntepreter : 1;
+    bool m_needsToUsePropertyFilterOnInterpreter : 1;
+    bool m_needsToUseBigPropertyFilterOnInterpreter : 1;
     bool m_hasPrecomputedKey : 1;
     bool m_needsToUpdateFunctionName : 1;
     bool m_isGetter : 1; // other case, this is setter

src/interpreter/ByteCodeInterpreter.cpp

@@ -3059,6 +3059,13 @@ NEVER_INLINE void InterpreterSlowPath::createObjectOperation(ExecutionState& sta
             }
         }
         obj->m_values.reset(data->m_values.takeBuffer());
+
+        if (UNLIKELY(data->m_needsToUseBigPropertyFilterOnInterpreter)) {
+            if (data->m_bigFilter) {
+                GC_FREE(data->m_bigFilter.value());
+            }
+        }
+
         if (isAsyncOrGenerator) {
             GC_FREE(data);
         } else {
@@ -3105,23 +3112,24 @@ NEVER_INLINE void InterpreterSlowPath::createObjectPrepareOperation(ExecutionSta
         }
         CreateObjectPrepare::CreateObjectData* data = new (ptr) CreateObjectPrepare::CreateObjectData(
             code->m_allPrecomputed, code->m_cachedObjectStructure.hasValue(), code->m_allPrecomputed,
-            code->m_needsToUsePropertyFilterOnIntepreter,
+            code->m_needsToUsePropertyFilterOnInterpreter, code->m_needsToUseBigPropertyFilterOnInterpreter,
             code->m_propertyReserveSize, new Object(state), code);
         registerFile[code->m_objectIndex] = data->m_target;
         if (data->m_wasStructureComputed) {
             data->m_target->m_structure = code->m_cachedObjectStructure.value();
         }
-        if (UNLIKELY(data->m_needsToUsePropertyFilterOnIntepreter)) {
+        if (UNLIKELY(data->m_needsToUsePropertyFilterOnInterpreter)) {
             if (byteCodeBlock->codeBlock()->isAsyncOrGenerator()) {
                 data->m_filter = new (PointerFreeGC) CreateObjectPrepare::CreateObjectPropertyFilter();
             } else {
                 size_t diff = sizeof(CreateObjectPrepare::CreateObjectData);
                 if (diff % sizeof(Value)) {
                     diff += (sizeof(Value) - (diff % sizeof(Value)));
                 }
-                data->m_filter = reinterpret_cast<CreateObjectPrepare::CreateObjectPropertyFilter*>(ptr + diff);
+                data->m_filter = new (reinterpret_cast<void*>(ptr + diff)) CreateObjectPrepare::CreateObjectPropertyFilter;
             }
-            data->m_filter->clear();
+        } else if (UNLIKELY(data->m_needsToUseBigPropertyFilterOnInterpreter)) {
+            data->m_bigFilter = new (PointerFreeGC) CreateObjectPrepare::CreateObjectBigPropertyFilter();
         }
     } else {
         ASSERT(code->m_stage == CreateObjectPrepare::FillKeyValue || code->m_stage == CreateObjectPrepare::DefineGetterSetter);
@@ -3160,20 +3168,24 @@ NEVER_INLINE void InterpreterSlowPath::createObjectPrepareOperation(ExecutionSta
         }
 
         bool needsPropertySearch = true;
-        if (UNLIKELY(data->m_needsToUsePropertyFilterOnIntepreter)) {
-            auto newPropertyNameHash = (propertyName.isSymbol() ?
-                propertyName.symbol()->descriptionString()->hashValue() : propertyName.plainString()->hashValue());
-            if (data->m_filter->mayContain(newPropertyNameHash)) {
-            } else {
+        size_t lastPropertyCount = data->m_properties.size();
+        size_t targetIndex = lastPropertyCount;
+        bool updateProperty = false;
+
+        if (UNLIKELY(data->m_needsToUsePropertyFilterOnInterpreter)) {
+            auto newPropertyNameHash = propertyName.hashValue();
+            if (!data->m_filter->mayContain(newPropertyNameHash)) {
                 data->m_filter->add(newPropertyNameHash);
                 needsPropertySearch = false;
             }
+        } else if (UNLIKELY(data->m_needsToUseBigPropertyFilterOnInterpreter)) {
+            auto newPropertyNameHash = propertyName.hashValue() * 13;
+            if (!data->m_bigFilter->mayContain(newPropertyNameHash)) {
+                data->m_bigFilter->add(newPropertyNameHash);
+                needsPropertySearch = false;
+            }
         }
 
-        size_t lastPropertyCount = data->m_properties.size();
-        size_t targetIndex = lastPropertyCount;
-        bool updateProperty = false;
-
         if (LIKELY(needsPropertySearch)) {
             for (size_t i = 0; i < lastPropertyCount; i++) {
                 if (data->m_properties[i].m_propertyName == propertyName) {

src/parser/ast/ObjectExpressionNode.h

@@ -60,11 +60,12 @@ class ObjectExpressionNode : public ExpressionNode {
         size_t objectCreationDataRegisterSize = 0;
         size_t initCodePosition = codeBlock->currentCodeSize();
 
-        bool needsToUseNameFilterOnIntepreter = m_properties.size() >= 6;
-        if (needsToUseNameFilterOnIntepreter) {
+        bool needsToUseBigPropertyFilterOnInterpreter = m_properties.size() >= 512;
+        bool needsToUseNameFilterOnInterpreter = !needsToUseBigPropertyFilterOnInterpreter && m_properties.size() >= 6;
+        if (needsToUseNameFilterOnInterpreter || needsToUseBigPropertyFilterOnInterpreter) {
             for (SentinelNode* property = m_properties.begin(); property != m_properties.end(); property = property->next()) {
                 if (!property->astNode()->isProperty()) {
-                    needsToUseNameFilterOnIntepreter = false;
+                    needsToUseBigPropertyFilterOnInterpreter = needsToUseNameFilterOnInterpreter = false;
                 }
             }
         }
@@ -79,15 +80,17 @@ class ObjectExpressionNode : public ExpressionNode {
                     objectCreationDataRegisterSize++;
                     context->getRegister();
                 }
-                if (needsToUseNameFilterOnIntepreter) {
+                if (needsToUseNameFilterOnInterpreter) {
                     for (size_t i = 0; i < sizeof(CreateObjectPrepare::CreateObjectPropertyFilter); i += sizeof(Value)) {
                         objectCreationDataRegisterSize++;
                         context->getRegister();
                     }
                 }
             }
 
-            codeBlock->pushCode(CreateObjectPrepare(ByteCodeLOC(m_loc.index), objectCreationDataIndex, dstRegister, needsToUseNameFilterOnIntepreter), context, this->m_loc.index);
+            codeBlock->pushCode(CreateObjectPrepare(ByteCodeLOC(m_loc.index), objectCreationDataIndex, dstRegister,
+                                                    needsToUseNameFilterOnInterpreter, needsToUseBigPropertyFilterOnInterpreter),
+                                context, this->m_loc.index);
         }
 
         bool allPrecomputed = true;