Optimize big object expression through bloom filter

ksh8281 · ksh8281 · commit 069fba11516c · 2026-03-10T16:01:03.000+09:00
Signed-off-by: Seonghyun Kim &lt;sh8281.kim@samsung.com&gt;
diff --git a/src/interpreter/ByteCode.h b/src/interpreter/ByteCode.h
@@ -23,6 +23,7 @@
 #include "interpreter/ByteCodeBlockData.h"
 #include "interpreter/ByteCodeGenerator.h"
 #include "runtime/ExecutionPauser.h"
+#include "util/BloomFilter.h"
 
 #ifndef NDEBUG
 #include "parser/CodeBlock.h"
@@ -964,19 +965,25 @@ class CreateObjectPrepare : public ByteCode {
         DefineGetterSetter,
     };
 
+    typedef BloomFilter<1024> CreateObjectPropertyFilter;
+
     struct CreateObjectData : public gc {
         bool m_allPrecomputed;
         bool m_wasStructureComputed;
         bool m_canStoreStructureOnCode;
+        bool m_needsToUsePropertyFilterOnIntepreter;
         VectorWithInlineStorage<6, ObjectStructureItem, GCUtil::gc_malloc_allocator<ObjectStructureItem>> m_properties;
         EncodedValueVector m_values;
         Object* m_target;
         CreateObjectPrepare* m_initCode;
+        Optional<CreateObjectPropertyFilter*> m_filter;
         CreateObjectData(bool allPrecomputed, bool wasStructureComputed, bool canStoreStructureOnCode,
+                         bool needsToUsePropertyFilterOnIntepreter,
                          size_t reserveSize, Object* target, CreateObjectPrepare* initCode)
             : m_allPrecomputed(allPrecomputed)
             , m_wasStructureComputed(wasStructureComputed)
             , m_canStoreStructureOnCode(canStoreStructureOnCode)
+            , m_needsToUsePropertyFilterOnIntepreter(needsToUsePropertyFilterOnIntepreter)
             , m_target(target)
             , m_initCode(initCode)
         {
@@ -987,10 +994,11 @@ class CreateObjectPrepare : public ByteCode {
         }
     };
 
-    CreateObjectPrepare(const ByteCodeLOC& loc, const size_t dataRegisterIndex, const size_t objectIndex)
+    CreateObjectPrepare(const ByteCodeLOC& loc, const size_t dataRegisterIndex, const size_t objectIndex, bool needsToUseNameFilterOnIntepreter)
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::Init)
         , m_allPrecomputed(false)
+        , m_needsToUsePropertyFilterOnIntepreter(needsToUseNameFilterOnIntepreter)
         , m_hasPrecomputedKey(false)
         , m_needsToUpdateFunctionName(false)
         , m_isGetter(false)
@@ -1004,6 +1012,7 @@ class CreateObjectPrepare : public ByteCode {
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::FillKeyValue)
         , m_allPrecomputed(false)
+        , m_needsToUsePropertyFilterOnIntepreter(false)
         , m_hasPrecomputedKey(hasPreComputedKey)
         , m_needsToUpdateFunctionName(needsToUpdateFunctionName)
         , m_isGetter(false)
@@ -1017,6 +1026,7 @@ class CreateObjectPrepare : public ByteCode {
         : ByteCode(Opcode::CreateObjectPrepareOpcode, loc)
         , m_stage(Stage::DefineGetterSetter)
         , m_allPrecomputed(false)
+        , m_needsToUsePropertyFilterOnIntepreter(false)
         , m_hasPrecomputedKey(hasPreComputedKey)
         , m_needsToUpdateFunctionName(false)
         , m_isGetter(isGetter)
@@ -1028,6 +1038,7 @@ class CreateObjectPrepare : public ByteCode {
 
     Stage m_stage : 2;
     bool m_allPrecomputed : 1;
+    bool m_needsToUsePropertyFilterOnIntepreter : 1;
     bool m_hasPrecomputedKey : 1;
     bool m_needsToUpdateFunctionName : 1;
     bool m_isGetter : 1; // other case, this is setter
diff --git a/src/interpreter/ByteCodeInterpreter.cpp b/src/interpreter/ByteCodeInterpreter.cpp
@@ -3094,22 +3094,35 @@ static Value createObjectPropertyFunctionName(ExecutionState& state, const Value
 NEVER_INLINE void InterpreterSlowPath::createObjectPrepareOperation(ExecutionState& state, CreateObjectPrepare* code, ByteCodeBlock* byteCodeBlock, Value* registerFile)
 {
     if (code->m_stage == CreateObjectPrepare::Init) {
-        void* ptr;
+        uint8_t* ptr;
         if (byteCodeBlock->codeBlock()->isAsyncOrGenerator()) {
             // async or generator uses ValueVector alloctor for allocating registerFile
             // ValueVector allocator cannot track CreateObjectData if there is CreateObjectData on registerFile
-            ptr = GC_MALLOC(sizeof(CreateObjectPrepare::CreateObjectData));
+            ptr = reinterpret_cast<uint8_t*>(GC_MALLOC(sizeof(CreateObjectPrepare::CreateObjectData)));
             registerFile[code->m_dataRegisterIndex] = Value(Value::FromPayload, reinterpret_cast<intptr_t>(ptr));
         } else {
-            ptr = &registerFile[code->m_dataRegisterIndex];
+            ptr = reinterpret_cast<uint8_t*>(&registerFile[code->m_dataRegisterIndex]);
         }
         CreateObjectPrepare::CreateObjectData* data = new (ptr) CreateObjectPrepare::CreateObjectData(
             code->m_allPrecomputed, code->m_cachedObjectStructure.hasValue(), code->m_allPrecomputed,
+            code->m_needsToUsePropertyFilterOnIntepreter,
             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 (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->clear();
+        }
     } else {
         ASSERT(code->m_stage == CreateObjectPrepare::FillKeyValue || code->m_stage == CreateObjectPrepare::DefineGetterSetter);
         CreateObjectPrepare::CreateObjectData* data;
@@ -3146,15 +3159,29 @@ NEVER_INLINE void InterpreterSlowPath::createObjectPrepareOperation(ExecutionSta
             return;
         }
 
+        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 {
+                data->m_filter->add(newPropertyNameHash);
+                needsPropertySearch = false;
+            }
+        }
+
         size_t lastPropertyCount = data->m_properties.size();
         size_t targetIndex = lastPropertyCount;
         bool updateProperty = false;
-        for (size_t i = 0; i < lastPropertyCount; i++) {
-            if (data->m_properties[i].m_propertyName == propertyName) {
-                targetIndex = i;
-                updateProperty = true;
-                data->m_canStoreStructureOnCode = false;
-                break;
+
+        if (LIKELY(needsPropertySearch)) {
+            for (size_t i = 0; i < lastPropertyCount; i++) {
+                if (data->m_properties[i].m_propertyName == propertyName) {
+                    targetIndex = i;
+                    updateProperty = true;
+                    data->m_canStoreStructureOnCode = false;
+                    break;
+                }
             }
         }
 
diff --git a/src/parser/ast/ObjectExpressionNode.h b/src/parser/ast/ObjectExpressionNode.h
@@ -60,6 +60,15 @@ class ObjectExpressionNode : public ExpressionNode {
         size_t objectCreationDataRegisterSize = 0;
         size_t initCodePosition = codeBlock->currentCodeSize();
 
+        bool needsToUseNameFilterOnIntepreter = m_properties.size() >= 6;
+        if (needsToUseNameFilterOnIntepreter) {
+            for (SentinelNode* property = m_properties.begin(); property != m_properties.end(); property = property->next()) {
+                if (!property->astNode()->isProperty()) {
+                    needsToUseNameFilterOnIntepreter = false;
+                }
+            }
+        }
+
         if (m_properties.size()) {
             objectCreationDataIndex = context->getRegister();
             objectCreationDataRegisterSize = 1;
@@ -70,9 +79,15 @@ class ObjectExpressionNode : public ExpressionNode {
                     objectCreationDataRegisterSize++;
                     context->getRegister();
                 }
+                if (needsToUseNameFilterOnIntepreter) {
+                    for (size_t i = 0; i < sizeof(CreateObjectPrepare::CreateObjectPropertyFilter); i += sizeof(Value)) {
+                        objectCreationDataRegisterSize++;
+                        context->getRegister();
+                    }
+                }
             }
 
-            codeBlock->pushCode(CreateObjectPrepare(ByteCodeLOC(m_loc.index), objectCreationDataIndex, dstRegister), context, this->m_loc.index);
+            codeBlock->pushCode(CreateObjectPrepare(ByteCodeLOC(m_loc.index), objectCreationDataIndex, dstRegister, needsToUseNameFilterOnIntepreter), context, this->m_loc.index);
         }
 
         bool allPrecomputed = true;
diff --git a/src/runtime/ObjectStructurePropertyName.h b/src/runtime/ObjectStructurePropertyName.h
@@ -48,7 +48,7 @@ class ObjectStructurePropertyName {
     // same as `ToPropertyKey` https://262.ecma-international.org/#sec-topropertykey
     ObjectStructurePropertyName(ExecutionState& state, const Value& value);
 
-    size_t hashValue() const
+    ALWAYS_INLINE size_t hashValue() const
     {
         if (LIKELY(hasAtomicString())) {
             std::hash<Escargot::AtomicString> hasher;

Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ class ObjectStructurePropertyName {`
`48`	`48`	// same as `ToPropertyKey` https://262.ecma-international.org/#sec-topropertykey
`49`	`49`	`ObjectStructurePropertyName(ExecutionState& state, const Value& value);`
`50`	`50`
`51`		`- size_t hashValue() const`
	`51`	`+ ALWAYS_INLINE size_t hashValue() const`
`52`	`52`	`{`
`53`	`53`	`if (LIKELY(hasAtomicString())) {`
`54`	`54`	`std::hash<Escargot::AtomicString> hasher;`