diff --git a/ecmascript/serializer/serialize_data.h b/ecmascript/serializer/serialize_data.h index 75b0cc28daa6d396673aa5174e273a871a465f61..74553c0672e31a41c0af0801114042db1128a62e 100644 --- a/ecmascript/serializer/serialize_data.h +++ b/ecmascript/serializer/serialize_data.h @@ -31,7 +31,11 @@ namespace panda::ecmascript { constexpr size_t INITIAL_CAPACITY = 64; constexpr int CAPACITY_INCREASE_RATE = 2; constexpr uint32_t RESERVED_INDEX = 0; +#ifdef USE_CMC_GC +static constexpr int SERIALIZE_SPACE_NUM = 3; +#else static constexpr int SERIALIZE_SPACE_NUM = 7; +#endif typedef void* (*DetachFunc)(void *enginePointer, void *objPointer, void *hint, void *detachData); typedef Local (*AttachFunc)(void *enginePointer, void *buffer, void *hint, void *attachData); @@ -75,8 +79,12 @@ enum class EncodeFlag : uint8_t { LAST }; -#ifndef USE_CMC_GC enum class SerializedObjectSpace : uint8_t { +#ifdef USE_CMC_GC + REGULAR_SPACE, + PIN_SPACE, + HUGE_SPACE, +#else OLD_SPACE, NON_MOVABLE_SPACE, MACHINE_CODE_SPACE, @@ -84,14 +92,42 @@ enum class SerializedObjectSpace : uint8_t { SHARED_OLD_SPACE, SHARED_NON_MOVABLE_SPACE, SHARED_HUGE_SPACE, -}; #endif +}; enum class SerializeType : uint8_t { VALUE_SERIALIZE, PGO_SERIALIZE }; +class SpaceData { +public: + SpaceData() = default; + ~SpaceData() = default; + + NO_COPY_SEMANTIC(SpaceData); + NO_MOVE_SEMANTIC(SpaceData); + + + void SetSpaceSize(SerializedObjectSpace space, size_t size) + { + spaceSizeArray_[static_cast(space)] = size; + } + + void IncSpaceSize(SerializedObjectSpace space, size_t size) + { + spaceSizeArray_[static_cast(space)] += size; + } + + size_t GetSpaceSize(SerializedObjectSpace space) const + { + return spaceSizeArray_[static_cast(space)]; + } + +private: + std::array spaceSizeArray_ {}; +}; + class SerializeData { public: explicit SerializeData(JSThread *thread) : thread_(thread) {} @@ -341,102 +377,97 @@ public: { return pinRemainSizeVector_; } -#else - const std::array, SERIALIZE_SPACE_NUM>& GetRegionRemainSizeVectors() const - { - return regionRemainSizeVectors_; - } -#endif size_t GetRegularSpaceSize() const { - return regularSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::REGULAR_SPACE); } size_t GetPinSpaceSize() const { - return pinSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::PIN_SPACE); + } + + bool IsRegularSpace(SerializedObjectSpace space) const + { + return static_cast(space) == static_cast(SerializedObjectSpace::REGULAR_SPACE); + } + + bool IsPinSpace(SerializedObjectSpace space) const + { + return static_cast(space) == static_cast(SerializedObjectSpace::PIN_SPACE); + } +#else + const std::array, SERIALIZE_SPACE_NUM>& GetRegionRemainSizeVectors() const + { + return regionRemainSizeVectors_; } size_t GetOldSpaceSize() const { - return oldSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::OLD_SPACE); } size_t GetNonMovableSpaceSize() const { - return nonMovableSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::NON_MOVABLE_SPACE); } size_t GetMachineCodeSpaceSize() const { - return machineCodeSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::MACHINE_CODE_SPACE); } size_t GetSharedOldSpaceSize() const { - return sharedOldSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::SHARED_OLD_SPACE); } size_t GetSharedNonMovableSpaceSize() const { - return sharedNonMovableSpaceSize_; + return spaceData_.GetSpaceSize(SerializedObjectSpace::SHARED_NON_MOVABLE_SPACE); } +#endif void CalculateSerializedObjectSize(SerializedObjectSpace space, size_t objectSize) { - switch (space) { #ifdef USE_CMC_GC - case SerializedObjectSpace::REGULAR_SPACE: - AlignSpaceObjectSize(regularRemainSizeVector_, regularSpaceSize_, objectSize); - break; - case SerializedObjectSpace::PIN_SPACE: - AlignSpaceObjectSize(pinRemainSizeVector_, pinSpaceSize_, objectSize); - break; + if (IsRegularSpace(space)) { + AlignSpaceObjectSize(regularRemainSizeVector_, objectSize, SerializedObjectSpace::REGULAR_SPACE); + return; + } + if (IsPinSpace(space)) { + AlignSpaceObjectSize(pinRemainSizeVector_, objectSize, SerializedObjectSpace::PIN_SPACE); + return; + } #else - case SerializedObjectSpace::OLD_SPACE: - AlignSpaceObjectSize(oldSpaceSize_, objectSize, SerializedObjectSpace::OLD_SPACE); - break; - case SerializedObjectSpace::NON_MOVABLE_SPACE: - AlignSpaceObjectSize(nonMovableSpaceSize_, objectSize, SerializedObjectSpace::NON_MOVABLE_SPACE); - break; - case SerializedObjectSpace::MACHINE_CODE_SPACE: - AlignSpaceObjectSize(machineCodeSpaceSize_, objectSize, SerializedObjectSpace::MACHINE_CODE_SPACE); - break; - case SerializedObjectSpace::SHARED_OLD_SPACE: - AlignSpaceObjectSize(sharedOldSpaceSize_, objectSize, SerializedObjectSpace::SHARED_OLD_SPACE); - break; - case SerializedObjectSpace::SHARED_NON_MOVABLE_SPACE: - AlignSpaceObjectSize(sharedNonMovableSpaceSize_, objectSize, - SerializedObjectSpace::SHARED_NON_MOVABLE_SPACE); - break; + AlignSpaceObjectSize(objectSize, space); #endif - default: - break; - } } #ifndef USE_CMC_GC - void AlignSpaceObjectSize(size_t &spaceSize, size_t objectSize, SerializedObjectSpace spaceType) + void AlignSpaceObjectSize(size_t objectSize, SerializedObjectSpace spaceType) { + size_t spaceSize = spaceData_.GetSpaceSize(spaceType); size_t alignRegionSize = AlignUpRegionAvailableSize(spaceSize); if (UNLIKELY(spaceSize + objectSize > alignRegionSize)) { regionRemainSizeVectors_.at(static_cast(spaceType)).push_back(alignRegionSize - spaceSize); - spaceSize = alignRegionSize; + spaceData_.SetSpaceSize(spaceType, alignRegionSize); } - spaceSize += objectSize; - ASSERT(spaceSize <= SnapshotEnv::MAX_UINT_32); + spaceData_.IncSpaceSize(spaceType, objectSize); + ASSERT(spaceData_.GetSpaceSize(spaceType) <= SnapshotEnv::MAX_UINT_32); } #else - void AlignSpaceObjectSize(std::vector &remainSizeVec, size_t &spaceSize, size_t objectSize) + void AlignSpaceObjectSize(std::vector &remainSizeVec, size_t objectSize, SerializedObjectSpace spaceType) { + size_t spaceSize = spaceData_.GetSpaceSize(spaceType); size_t alignRegionSize = AlignUpRegionAvailableSize(spaceSize); if (UNLIKELY(spaceSize + objectSize > alignRegionSize)) { remainSizeVec.push_back(alignRegionSize - spaceSize); - spaceSize = alignRegionSize; + spaceData_.SetSpaceSize(spaceType, alignRegionSize); } - spaceSize += objectSize; - ASSERT(spaceSize <= SnapshotEnv::MAX_UINT_32); + spaceData_.IncSpaceSize(spaceType, objectSize); + ASSERT(spaceData_.GetSpaceSize(spaceType) <= SnapshotEnv::MAX_UINT_32); } #endif @@ -481,13 +512,7 @@ private: uint64_t sizeLimit_ {0}; size_t bufferSize_ {0}; size_t bufferCapacity_ {0}; - size_t regularSpaceSize_ {0}; - size_t pinSpaceSize_ {0}; - size_t oldSpaceSize_ {0}; - size_t nonMovableSpaceSize_ {0}; - size_t machineCodeSpaceSize_ {0}; - size_t sharedOldSpaceSize_ {0}; - size_t sharedNonMovableSpaceSize_ {0}; + SpaceData spaceData_; bool incompleteData_ {false}; #ifdef USE_CMC_GC std::vector regularRemainSizeVector_ {}; diff --git a/ecmascript/serializer/value_serializer.cpp b/ecmascript/serializer/value_serializer.cpp index 1acb2a6300614b47a1fda0a483d5f5635f56a562..97e5ec0f9995a4bceafbe885b91faa93d9bd1a25 100644 --- a/ecmascript/serializer/value_serializer.cpp +++ b/ecmascript/serializer/value_serializer.cpp @@ -215,6 +215,21 @@ void ValueSerializer::SerializeObjectImpl(TaggedObject *object, bool isWeak) JSTaggedType hashfield = JSTaggedValue::VALUE_ZERO; JSType type = objClass->GetObjectType(); // serialize prologue + SerializePrologue(object, type, trackInfo, hashfield, arrayBufferDeferDetach); + + // serialize object here + SerializeTaggedObject(object); + + // serialize epilogue + SerializeEpilogue(object, type, trackInfo, hashfield, arrayBufferDeferDetach); + if (cloneSharedObject) { + serializeSharedEvent_--; + } +} + +void ValueSerializer::SerializePrologue(TaggedObject *object, JSType type, JSTaggedValue &trackInfo, + JSTaggedType &hashfield, bool &arrayBufferDeferDetach) +{ switch (type) { case JSType::JS_ARRAY_BUFFER: { supportJSNativePointer_ = true; @@ -250,11 +265,11 @@ void ValueSerializer::SerializeObjectImpl(TaggedObject *object, bool isWeak) default: break; } +} - // serialize object here - SerializeTaggedObject(object); - - // serialize epilogue +void ValueSerializer::SerializeEpilogue(TaggedObject *object, JSType type, JSTaggedValue trackInfo, + JSTaggedType hashfield, bool arrayBufferDeferDetach) +{ switch (type) { case JSType::JS_ARRAY_BUFFER: case JSType::JS_SHARED_ARRAY_BUFFER: @@ -280,9 +295,6 @@ void ValueSerializer::SerializeObjectImpl(TaggedObject *object, bool isWeak) default: break; } - if (cloneSharedObject) { - serializeSharedEvent_--; - } if (arrayBufferDeferDetach) { ASSERT(objClass->IsArrayBuffer()); JSArrayBuffer *arrayBuffer = reinterpret_cast(object); diff --git a/ecmascript/serializer/value_serializer.h b/ecmascript/serializer/value_serializer.h index 68240499f819c17b5b0bc01133f6e9f7ca0af50e..94474a62050d8f299049ad08ec74997362d4de53 100644 --- a/ecmascript/serializer/value_serializer.h +++ b/ecmascript/serializer/value_serializer.h @@ -48,13 +48,31 @@ private: bool PrepareTransfer(JSThread *thread, const JSHandle &transfer); bool PrepareClone(JSThread *thread, const JSHandle &cloneList); bool CheckObjectCanSerialize(TaggedObject *object, bool &findSharedObject); + void SerializePrologue(TaggedObject *object, JSType type, JSTaggedValue &trackInfo, JSTaggedType &hashfield, + bool &arrayBufferDeferDetach); + void SerializeEpilogue(TaggedObject *object, JSType type, JSTaggedValue trackInfo, JSTaggedType hashfield, + bool arrayBufferDeferDetach); bool IsInternalJSType(JSType type) { - if ((type >= JSType::JS_RECORD_FIRST && type <= JSType::JS_RECORD_LAST) || - (type == JSType::JS_NATIVE_POINTER && !supportJSNativePointer_)) { + if (IsRecordType(type) || IsLocalJSNativePointer(type) || IsSymbol(type)) { return false; } - return type >= JSType::HCLASS && type <= JSType::TYPE_LAST && type != JSType::SYMBOL; + return type >= JSType::HCLASS && type <= JSType::TYPE_LAST; + } + + bool IsRecordType(JSType type) const + { + return type >= JSType::JS_RECORD_FIRST && type <= JSType::JS_RECORD_LAST; + } + + bool IsLocalJSNativePointer(JSType type) const + { + return type == JSType::JS_NATIVE_POINTER && !supportJSNativePointer_; + } + + bool IsSymbol(JSType type) const + { + return type == JSType::SYMBOL; } private: