1 /* 2 * Copyright (c) 2025 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 COMMON_COMPONENTS_HEAP_BARRIER_BARRIER_H 17 #define COMMON_COMPONENTS_HEAP_BARRIER_BARRIER_H 18 19 #include "common_components/common/base_object.h" 20 #include "common_components/common/type_def.h" 21 #include <vector> 22 23 namespace common { 24 class Collector; 25 // Barrier is the base class to define read/write barriers. 26 class Barrier { 27 public: 28 static constexpr uint64_t TAG_WEAK = 0x01ULL; Barrier(Collector & collector)29 explicit Barrier(Collector& collector) : theCollector(collector) {} ~Barrier()30 virtual ~Barrier() {} 31 32 virtual BaseObject* ReadRefField(BaseObject* obj, RefField<false>& field) const; 33 virtual BaseObject* ReadStaticRef(RefField<false>& field) const; 34 virtual BaseObject* ReadStringTableStaticRef(RefField<false> &field) const; 35 36 virtual void ReadStruct(HeapAddress dst, BaseObject* obj, HeapAddress src, size_t size) const; 37 38 virtual void WriteRoot(BaseObject* obj) const; 39 virtual void WriteRefField(BaseObject* obj, RefField<false>& field, BaseObject* ref) const; 40 virtual void WriteBarrier(BaseObject* obj, RefField<false>& field, BaseObject* ref) const; 41 42 virtual void WriteStaticRef(RefField<false>& field, BaseObject* ref) const; 43 virtual void WriteStruct(BaseObject* obj, HeapAddress dst, size_t dstLen, HeapAddress src, size_t srcLen) const; 44 45 virtual void CopyStructArray(BaseObject* dstObj, HeapAddress dstField, MIndex dstSize, 46 BaseObject* srcObj, HeapAddress srcField, MIndex srcSize) const; 47 48 virtual BaseObject* AtomicReadRefField(BaseObject* obj, RefField<true>& field, 49 MemoryOrder order) const; 50 51 virtual void AtomicWriteRefField(BaseObject* obj, RefField<true>& field, BaseObject* ref, MemoryOrder order) const; 52 virtual BaseObject* AtomicSwapRefField(BaseObject* obj, RefField<true>& field, BaseObject* ref, 53 MemoryOrder order) const; 54 virtual bool CompareAndSwapRefField(BaseObject* obj, RefField<true>& field, BaseObject* oldRef, BaseObject* newRef, 55 MemoryOrder succOrder, MemoryOrder failOrder) const; 56 57 protected: 58 class LocalRefFieldContainer { 59 public: 60 // multi-thread unsafe. Push(RefField<> * ref)61 void Push(RefField<>* ref) 62 { 63 if (size_ >= CACHE_CAPACITY) { 64 excessive_.push_back(ref); 65 } else { 66 cache_[size_] = ref; 67 } 68 size_++; 69 } VisitRefField(const RefFieldVisitor & visitor)70 void VisitRefField(const RefFieldVisitor &visitor) 71 { 72 size_t cacheSize = size_ < CACHE_CAPACITY ? size_ : CACHE_CAPACITY; 73 for (size_t i = 0; i != cacheSize; ++i) { 74 visitor(*cache_[i]); 75 } 76 for (auto* ref : excessive_) { 77 visitor(*ref); 78 } 79 } 80 private: 81 static constexpr size_t CACHE_CAPACITY = 10; 82 RefField<>* cache_[CACHE_CAPACITY]{ nullptr }; 83 size_t size_{ 0 }; 84 std::vector<RefField<>*> excessive_; 85 }; 86 Collector& theCollector; 87 }; 88 } // namespace common 89 90 #endif // COMMON_COMPONENTS_HEAP_BARRIER_BARRIER_H 91