1 /*
2 * Copyright (c) 2021 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_PARALLEL_EVACUATION_INL_H
17 #define ECMASCRIPT_MEM_PARALLEL_EVACUATION_INL_H
18
19 #include "ecmascript/mem/parallel_evacuation.h"
20
21 #include "ecmascript/mem/heap.h"
22 #include "ecmascript/mem/mark_word.h"
23 #include "ecmascript/mem/region-inl.h"
24 #include "ecmascript/mem/remembered_set.h"
25 #include "ecmascript/platform/platform.h"
26
27 namespace panda::ecmascript {
28 // Move regions with a survival rate of more than 75% to new space
IsWholeRegionEvacuate(Region * region)29 bool ParallelEvacuation::IsWholeRegionEvacuate(Region *region)
30 {
31 return (static_cast<double>(region->AliveObject()) / region->GetSize()) > MIN_OBJECT_SURVIVAL_RATE &&
32 !region->HasAgeMark();
33 }
34
UpdateObjectSlot(ObjectSlot & slot)35 bool ParallelEvacuation::UpdateObjectSlot(ObjectSlot &slot)
36 {
37 JSTaggedValue value(slot.GetTaggedType());
38 if (value.IsHeapObject()) {
39 if (value.IsWeakForHeapObject()) {
40 return UpdateWeakObjectSlot(value.GetTaggedWeakRef(), slot);
41 }
42 TaggedObject *object = value.GetTaggedObject();
43 MarkWord markWord(object);
44 if (markWord.IsForwardingAddress()) {
45 TaggedObject *dst = markWord.ToForwardingAddress();
46 slot.Update(dst);
47 return true;
48 }
49 }
50 return false;
51 }
52
UpdateWeakObjectSlot(TaggedObject * value,ObjectSlot & slot)53 bool ParallelEvacuation::UpdateWeakObjectSlot(TaggedObject *value, ObjectSlot &slot)
54 {
55 Region *objectRegion = Region::ObjectAddressToRange(value);
56 if (objectRegion->InYoungOrCSetGeneration()) {
57 if (objectRegion->InNewToNewSet()) {
58 auto markBitmap = objectRegion->GetMarkBitmap();
59 if (!markBitmap->Test(value)) {
60 slot.Update(static_cast<JSTaggedType>(JSTaggedValue::Undefined().GetRawData()));
61 }
62 } else {
63 MarkWord markWord(value);
64 if (markWord.IsForwardingAddress()) {
65 TaggedObject *dst = markWord.ToForwardingAddress();
66 auto weakRef = JSTaggedValue(JSTaggedValue(dst).CreateAndGetWeakRef()).GetRawTaggedObject();
67 slot.Update(weakRef);
68 return true;
69 }
70 slot.Update(static_cast<JSTaggedType>(JSTaggedValue::Undefined().GetRawData()));
71 }
72 return false;
73 }
74
75 if (heap_->IsFullMark()) {
76 auto markBitmap = objectRegion->GetMarkBitmap();
77 if (!markBitmap->Test(value)) {
78 slot.Update(static_cast<JSTaggedType>(JSTaggedValue::Undefined().GetRawData()));
79 }
80 }
81 return false;
82 }
83
SetObjectFieldRSet(TaggedObject * object,JSHClass * cls)84 void ParallelEvacuation::SetObjectFieldRSet(TaggedObject *object, JSHClass *cls)
85 {
86 Region *region = Region::ObjectAddressToRange(object);
87 auto callbackWithCSet = [this, region](TaggedObject *root, ObjectSlot start, ObjectSlot end) {
88 for (ObjectSlot slot = start; slot < end; slot++) {
89 JSTaggedType value = slot.GetTaggedType();
90 if (JSTaggedValue(value).IsHeapObject()) {
91 Region *valueRegion = Region::ObjectAddressToRange(value);
92 if (valueRegion->InYoungGeneration()) {
93 region->InsertOldToNewRememberedSet(slot.SlotAddress());
94 } else if (valueRegion->InCollectSet() || JSTaggedValue(value).IsWeakForHeapObject()) {
95 region->InsertCrossRegionRememberedSet(slot.SlotAddress());
96 }
97 }
98 }
99 };
100 objXRay_.VisitObjectBody<GCType::OLD_GC>(object, cls, callbackWithCSet);
101 }
102
103
GetFragmentSafe()104 std::unique_ptr<ParallelEvacuation::Fragment> ParallelEvacuation::GetFragmentSafe()
105 {
106 os::memory::LockHolder holder(mutex_);
107 std::unique_ptr<Fragment> unit;
108 if (!fragments_.empty()) {
109 unit = std::move(fragments_.back());
110 fragments_.pop_back();
111 }
112 return unit;
113 }
114
AddFragment(std::unique_ptr<Fragment> region)115 void ParallelEvacuation::AddFragment(std::unique_ptr<Fragment> region)
116 {
117 fragments_.emplace_back(std::move(region));
118 }
119
CalculateEvacuationThreadNum()120 int ParallelEvacuation::CalculateEvacuationThreadNum()
121 {
122 int length = fragments_.size();
123 int regionPerThread = 8;
124 int maxThreadNum = Platform::GetCurrentPlatform()->GetTotalThreadNum();
125 return std::min(std::max(1, length / regionPerThread), maxThreadNum);
126 }
127
CalculateUpdateThreadNum()128 int ParallelEvacuation::CalculateUpdateThreadNum()
129 {
130 int length = fragments_.size();
131 double regionPerThread = 1.0 / 4;
132 length = static_cast<int>(std::pow(length, regionPerThread));
133 int maxThreadNum = Platform::GetCurrentPlatform()->GetTotalThreadNum();
134 return std::min(std::max(1, length), maxThreadNum);
135 }
136 } // namespace panda::ecmascript
137 #endif // ECMASCRIPT_MEM_PARALLEL_EVACUATION_INL_H
138