1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "zygote_space.h"
18
19 #include "gc/accounting/card_table-inl.h"
20 #include "gc/accounting/space_bitmap-inl.h"
21 #include "gc/heap.h"
22 #include "thread-inl.h"
23 #include "utils.h"
24
25 namespace art {
26 namespace gc {
27 namespace space {
28
29 class CountObjectsAllocated {
30 public:
CountObjectsAllocated(size_t * objects_allocated)31 explicit CountObjectsAllocated(size_t* objects_allocated)
32 : objects_allocated_(objects_allocated) {}
33
operator ()(mirror::Object * obj) const34 void operator()(mirror::Object* obj) const {
35 UNUSED(obj);
36 ++*objects_allocated_;
37 }
38
39 private:
40 size_t* const objects_allocated_;
41 };
42
Create(const std::string & name,MemMap * mem_map,accounting::ContinuousSpaceBitmap * live_bitmap,accounting::ContinuousSpaceBitmap * mark_bitmap)43 ZygoteSpace* ZygoteSpace::Create(const std::string& name, MemMap* mem_map,
44 accounting::ContinuousSpaceBitmap* live_bitmap,
45 accounting::ContinuousSpaceBitmap* mark_bitmap) {
46 DCHECK(live_bitmap != nullptr);
47 DCHECK(mark_bitmap != nullptr);
48 size_t objects_allocated = 0;
49 CountObjectsAllocated visitor(&objects_allocated);
50 ReaderMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
51 live_bitmap->VisitMarkedRange(reinterpret_cast<uintptr_t>(mem_map->Begin()),
52 reinterpret_cast<uintptr_t>(mem_map->End()), visitor);
53 ZygoteSpace* zygote_space = new ZygoteSpace(name, mem_map, objects_allocated);
54 CHECK(zygote_space->live_bitmap_.get() == nullptr);
55 CHECK(zygote_space->mark_bitmap_.get() == nullptr);
56 zygote_space->live_bitmap_.reset(live_bitmap);
57 zygote_space->mark_bitmap_.reset(mark_bitmap);
58 return zygote_space;
59 }
60
Clear()61 void ZygoteSpace::Clear() {
62 UNIMPLEMENTED(FATAL);
63 UNREACHABLE();
64 }
65
ZygoteSpace(const std::string & name,MemMap * mem_map,size_t objects_allocated)66 ZygoteSpace::ZygoteSpace(const std::string& name, MemMap* mem_map, size_t objects_allocated)
67 : ContinuousMemMapAllocSpace(name, mem_map, mem_map->Begin(), mem_map->End(), mem_map->End(),
68 kGcRetentionPolicyFullCollect),
69 objects_allocated_(objects_allocated) {
70 }
71
Dump(std::ostream & os) const72 void ZygoteSpace::Dump(std::ostream& os) const {
73 os << GetType()
74 << " begin=" << reinterpret_cast<void*>(Begin())
75 << ",end=" << reinterpret_cast<void*>(End())
76 << ",size=" << PrettySize(Size())
77 << ",name=\"" << GetName() << "\"]";
78 }
79
Alloc(Thread *,size_t,size_t *,size_t *,size_t *)80 mirror::Object* ZygoteSpace::Alloc(Thread*, size_t, size_t*, size_t*, size_t*) {
81 UNIMPLEMENTED(FATAL);
82 UNREACHABLE();
83 }
84
AllocationSize(mirror::Object *,size_t *)85 size_t ZygoteSpace::AllocationSize(mirror::Object*, size_t*) {
86 UNIMPLEMENTED(FATAL);
87 UNREACHABLE();
88 }
89
Free(Thread *,mirror::Object *)90 size_t ZygoteSpace::Free(Thread*, mirror::Object*) {
91 UNIMPLEMENTED(FATAL);
92 UNREACHABLE();
93 }
94
FreeList(Thread *,size_t,mirror::Object **)95 size_t ZygoteSpace::FreeList(Thread*, size_t, mirror::Object**) {
96 UNIMPLEMENTED(FATAL);
97 UNREACHABLE();
98 }
99
LogFragmentationAllocFailure(std::ostream &,size_t)100 void ZygoteSpace::LogFragmentationAllocFailure(std::ostream&, size_t) {
101 UNIMPLEMENTED(FATAL);
102 UNREACHABLE();
103 }
104
SweepCallback(size_t num_ptrs,mirror::Object ** ptrs,void * arg)105 void ZygoteSpace::SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg) {
106 SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
107 DCHECK(context->space->IsZygoteSpace());
108 ZygoteSpace* zygote_space = context->space->AsZygoteSpace();
109 Locks::heap_bitmap_lock_->AssertExclusiveHeld(context->self);
110 accounting::CardTable* card_table = Runtime::Current()->GetHeap()->GetCardTable();
111 // If the bitmaps aren't swapped we need to clear the bits since the GC isn't going to re-swap
112 // the bitmaps as an optimization.
113 if (!context->swap_bitmaps) {
114 accounting::ContinuousSpaceBitmap* bitmap = zygote_space->GetLiveBitmap();
115 for (size_t i = 0; i < num_ptrs; ++i) {
116 bitmap->Clear(ptrs[i]);
117 }
118 }
119 // We don't free any actual memory to avoid dirtying the shared zygote pages.
120 for (size_t i = 0; i < num_ptrs; ++i) {
121 // Need to mark the card since this will update the mod-union table next GC cycle.
122 card_table->MarkCard(ptrs[i]);
123 }
124 zygote_space->objects_allocated_.FetchAndSubSequentiallyConsistent(num_ptrs);
125 }
126
127 } // namespace space
128 } // namespace gc
129 } // namespace art
130