1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ECMASCRIPT_MEM_SHARED_HEAP_SHARED_GC_MARKER_H 17 #define ECMASCRIPT_MEM_SHARED_HEAP_SHARED_GC_MARKER_H 18 19 #include "ecmascript/js_hclass.h" 20 #include "ecmascript/mem/rset_worklist_handler-inl.h" 21 #include "ecmascript/mem/slots.h" 22 #include "ecmascript/mem/work_manager.h" 23 24 namespace panda::ecmascript { 25 class Region; 26 class TaggedObject; 27 class SharedGCMarker; 28 class JSHClass; 29 class SharedFullGCMarkRootVisitor; 30 class SharedFullGCMarkObjectVisitor; 31 enum class Root; 32 33 enum class SharedMarkType : uint8_t { 34 NOT_CONCURRENT_MARK, 35 CONCURRENT_MARK_INITIAL_MARK, 36 CONCURRENT_MARK_REMARK, 37 }; 38 39 class SharedGCMarkerBase { 40 public: SharedGCMarkerBase(SharedGCWorkManager * workManger)41 explicit SharedGCMarkerBase(SharedGCWorkManager *workManger) : sWorkManager_(workManger) {} 42 virtual ~SharedGCMarkerBase() = default; 43 44 void ResetWorkManager(SharedGCWorkManager *workManager); 45 void MarkRoots(RootVisitor &visitor, SharedMarkType markType); 46 void MarkLocalVMRoots(RootVisitor &visitor, EcmaVM *localVm, SharedMarkType markType); 47 void CollectLocalVMRSet(EcmaVM *localVm); 48 void MarkStringCache(RootVisitor &visitor); 49 void MarkSerializeRoots(RootVisitor &visitor); 50 void MarkSharedModule(RootVisitor &visitor); 51 inline void ProcessThenMergeBackRSetFromBoundJSThread(RSetWorkListHandler *handler); 52 template<SharedMarkType markType> 53 inline void DoMark(uint32_t threadId); 54 inline void HandleLocalRoots(uint32_t threadId, [[maybe_unused]] Root type, ObjectSlot slot); 55 inline void HandleLocalRangeRoots(uint32_t threadId, [[maybe_unused]] Root type, ObjectSlot start, 56 ObjectSlot end); 57 inline void RecordWeakReference(uint32_t threadId, JSTaggedType *ref); 58 void MergeBackAndResetRSetWorkListHandler(); 59 template<SharedMarkType markType> 60 inline void ProcessVisitorOfDoMark(uint32_t threadId); 61 inline void ProcessVisitor(RSetWorkListHandler *handler); 62 inline bool MarkObjectOfProcessVisitor(void *mem, WorkNode *&localBuffer); 63 64 inline void MarkObjectFromJSThread(WorkNode *&localBuffer, TaggedObject *object); 65 MarkObject(uint32_t threadId,TaggedObject * object,ObjectSlot & slot)66 virtual inline void MarkObject([[maybe_unused]] uint32_t threadId, [[maybe_unused]] TaggedObject *object, 67 [[maybe_unused]] ObjectSlot &slot) 68 { 69 LOG_GC(FATAL) << " can not call this method"; 70 } 71 ProcessMarkStack(uint32_t threadId)72 virtual void ProcessMarkStack([[maybe_unused]] uint32_t threadId) 73 { 74 LOG_GC(FATAL) << " can not call this method"; 75 } 76 77 protected: 78 SharedGCWorkManager *sWorkManager_ {nullptr}; 79 80 private: 81 // This method is called within the GCIterateThreadList method, 82 // so the thread lock problem does not need to be considered. 83 inline void NotifyThreadProcessRsetStart(JSThread *localThread); 84 inline void NotifyThreadProcessRsetFinished(JSThread *localThread); 85 86 template<SharedMarkType markType> 87 inline auto GenerateRSetVisitor(uint32_t threadId); 88 inline void RecordObject(JSTaggedValue value, uint32_t threadId, void *mem); 89 template<SharedMarkType markType> 90 inline bool GetVisitor(JSTaggedValue value, uint32_t threadId, void *mem); 91 92 std::vector<RSetWorkListHandler*> rSetHandlers_; 93 }; 94 95 class SharedGCMarker final : public SharedGCMarkerBase { 96 public: 97 explicit SharedGCMarker(SharedGCWorkManager *workManger); 98 ~SharedGCMarker() override = default; 99 void ProcessMarkStack(uint32_t threadId) override; 100 101 protected: 102 inline void MarkObject(uint32_t threadId, TaggedObject *object, ObjectSlot &slot) override; 103 }; 104 105 class SharedGCMovableMarker final : public SharedGCMarkerBase { 106 public: 107 explicit SharedGCMovableMarker(SharedGCWorkManager *workManger, SharedHeap *sHeap); 108 ~SharedGCMovableMarker() override = default; 109 inline bool NeedEvacuate(Region *region); 110 void ProcessMarkStack(uint32_t threadId) override; 111 112 protected: 113 inline void MarkValue(uint32_t threadId, ObjectSlot &slot); 114 inline void MarkObject(uint32_t threadId, TaggedObject *object, ObjectSlot &slot) override; 115 inline uintptr_t AllocateForwardAddress(uint32_t threadId, size_t size); 116 inline void EvacuateObject(uint32_t threadId, TaggedObject *object, const MarkWord &markWord, ObjectSlot slot); 117 inline uintptr_t AllocateDstSpace(uint32_t threadId, size_t size); 118 inline void RawCopyObject(uintptr_t fromAddress, uintptr_t toAddress, size_t size, const MarkWord &markWord); 119 inline void UpdateForwardAddressIfSuccess(uint32_t threadId, TaggedObject *object, JSHClass *klass, 120 uintptr_t toAddress, size_t size, ObjectSlot slot); 121 inline void UpdateForwardAddressIfFailed(TaggedObject *object, uintptr_t toAddress, size_t size, ObjectSlot slot); 122 123 private: 124 SharedHeap *sHeap_; 125 126 friend class SharedFullGCMarkRootVisitor; 127 friend class SharedFullGCMarkObjectVisitor; 128 }; 129 } // namespace panda::ecmascript 130 #endif // ECMASCRIPT_MEM_SHARED_HEAP_SHARED_GC_MARKER_H