blob: f90e6c7695c5b60d1508459927b43ea331eff7a2 [file] [log] [blame]
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07001/*
2 * Copyright (C) 2013 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 "malloc_space.h"
18
Mathieu Chartierec050072014-01-07 16:00:07 -080019#include "gc/accounting/card_table-inl.h"
20#include "gc/accounting/space_bitmap-inl.h"
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070021#include "gc/heap.h"
Mathieu Chartiera1602f22014-01-13 17:19:19 -080022#include "gc/space/space-inl.h"
23#include "gc/space/zygote_space.h"
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070024#include "mirror/class-inl.h"
25#include "mirror/object-inl.h"
26#include "runtime.h"
27#include "thread.h"
28#include "thread_list.h"
29#include "utils.h"
30
31namespace art {
32namespace gc {
33namespace space {
34
35size_t MallocSpace::bitmap_index_ = 0;
36
37MallocSpace::MallocSpace(const std::string& name, MemMap* mem_map,
Mathieu Chartiera1602f22014-01-13 17:19:19 -080038 byte* begin, byte* end, byte* limit, size_t growth_limit,
39 bool create_bitmaps)
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070040 : ContinuousMemMapAllocSpace(name, mem_map, begin, end, limit, kGcRetentionPolicyAlwaysCollect),
41 recent_free_pos_(0), lock_("allocation space lock", kAllocSpaceLock),
42 growth_limit_(growth_limit) {
Mathieu Chartiera1602f22014-01-13 17:19:19 -080043 if (create_bitmaps) {
44 size_t bitmap_index = bitmap_index_++;
45 static const uintptr_t kGcCardSize = static_cast<uintptr_t>(accounting::CardTable::kCardSize);
46 CHECK(IsAligned<kGcCardSize>(reinterpret_cast<uintptr_t>(mem_map->Begin())));
47 CHECK(IsAligned<kGcCardSize>(reinterpret_cast<uintptr_t>(mem_map->End())));
48 live_bitmap_.reset(accounting::SpaceBitmap::Create(
49 StringPrintf("allocspace %s live-bitmap %d", name.c_str(), static_cast<int>(bitmap_index)),
50 Begin(), Capacity()));
51 DCHECK(live_bitmap_.get() != NULL) << "could not create allocspace live bitmap #"
52 << bitmap_index;
53 mark_bitmap_.reset(accounting::SpaceBitmap::Create(
54 StringPrintf("allocspace %s mark-bitmap %d", name.c_str(), static_cast<int>(bitmap_index)),
55 Begin(), Capacity()));
56 DCHECK(live_bitmap_.get() != NULL) << "could not create allocspace mark bitmap #"
57 << bitmap_index;
58 }
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070059 for (auto& freed : recent_freed_objects_) {
60 freed.first = nullptr;
61 freed.second = nullptr;
62 }
63}
64
65MemMap* MallocSpace::CreateMemMap(const std::string& name, size_t starting_size, size_t* initial_size,
66 size_t* growth_limit, size_t* capacity, byte* requested_begin) {
67 // Sanity check arguments
68 if (starting_size > *initial_size) {
69 *initial_size = starting_size;
70 }
71 if (*initial_size > *growth_limit) {
72 LOG(ERROR) << "Failed to create alloc space (" << name << ") where the initial size ("
73 << PrettySize(*initial_size) << ") is larger than its capacity ("
74 << PrettySize(*growth_limit) << ")";
75 return NULL;
76 }
77 if (*growth_limit > *capacity) {
78 LOG(ERROR) << "Failed to create alloc space (" << name << ") where the growth limit capacity ("
79 << PrettySize(*growth_limit) << ") is larger than the capacity ("
80 << PrettySize(*capacity) << ")";
81 return NULL;
82 }
83
84 // Page align growth limit and capacity which will be used to manage mmapped storage
85 *growth_limit = RoundUp(*growth_limit, kPageSize);
86 *capacity = RoundUp(*capacity, kPageSize);
87
88 std::string error_msg;
89 MemMap* mem_map = MemMap::MapAnonymous(name.c_str(), requested_begin, *capacity,
Ian Rogersef7d42f2014-01-06 12:55:46 -080090 PROT_READ | PROT_WRITE, true, &error_msg);
Mathieu Chartiere6da9af2013-12-16 11:54:42 -080091 if (mem_map == nullptr) {
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070092 LOG(ERROR) << "Failed to allocate pages for alloc space (" << name << ") of size "
93 << PrettySize(*capacity) << ": " << error_msg;
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070094 }
95 return mem_map;
96}
97
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -070098mirror::Class* MallocSpace::FindRecentFreedObject(const mirror::Object* obj) {
99 size_t pos = recent_free_pos_;
100 // Start at the most recently freed object and work our way back since there may be duplicates
101 // caused by dlmalloc reusing memory.
102 if (kRecentFreeCount > 0) {
103 for (size_t i = 0; i + 1 < kRecentFreeCount + 1; ++i) {
104 pos = pos != 0 ? pos - 1 : kRecentFreeMask;
105 if (recent_freed_objects_[pos].first == obj) {
106 return recent_freed_objects_[pos].second;
107 }
108 }
109 }
110 return nullptr;
111}
112
113void MallocSpace::RegisterRecentFree(mirror::Object* ptr) {
114 recent_freed_objects_[recent_free_pos_] = std::make_pair(ptr, ptr->GetClass());
115 recent_free_pos_ = (recent_free_pos_ + 1) & kRecentFreeMask;
116}
117
118void MallocSpace::SetGrowthLimit(size_t growth_limit) {
119 growth_limit = RoundUp(growth_limit, kPageSize);
120 growth_limit_ = growth_limit;
121 if (Size() > growth_limit_) {
122 end_ = begin_ + growth_limit;
123 }
124}
125
126void* MallocSpace::MoreCore(intptr_t increment) {
127 CheckMoreCoreForPrecondition();
128 byte* original_end = end_;
129 if (increment != 0) {
130 VLOG(heap) << "MallocSpace::MoreCore " << PrettySize(increment);
131 byte* new_end = original_end + increment;
132 if (increment > 0) {
133 // Should never be asked to increase the allocation beyond the capacity of the space. Enforced
134 // by mspace_set_footprint_limit.
135 CHECK_LE(new_end, Begin() + Capacity());
136 CHECK_MEMORY_CALL(mprotect, (original_end, increment, PROT_READ | PROT_WRITE), GetName());
137 } else {
138 // Should never be asked for negative footprint (ie before begin). Zero footprint is ok.
139 CHECK_GE(original_end + increment, Begin());
140 // Advise we don't need the pages and protect them
141 // TODO: by removing permissions to the pages we may be causing TLB shoot-down which can be
142 // expensive (note the same isn't true for giving permissions to a page as the protected
143 // page shouldn't be in a TLB). We should investigate performance impact of just
144 // removing ignoring the memory protection change here and in Space::CreateAllocSpace. It's
145 // likely just a useful debug feature.
146 size_t size = -increment;
147 CHECK_MEMORY_CALL(madvise, (new_end, size, MADV_DONTNEED), GetName());
148 CHECK_MEMORY_CALL(mprotect, (new_end, size, PROT_NONE), GetName());
149 }
150 // Update end_
151 end_ = new_end;
152 }
153 return original_end;
154}
155
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800156ZygoteSpace* MallocSpace::CreateZygoteSpace(const char* alloc_space_name, bool low_memory_mode,
157 MallocSpace** out_malloc_space) {
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700158 // For RosAlloc, revoke thread local runs before creating a new
159 // alloc space so that we won't mix thread local runs from different
160 // alloc spaces.
161 RevokeAllThreadLocalBuffers();
162 end_ = reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(end_), kPageSize));
163 DCHECK(IsAligned<accounting::CardTable::kCardSize>(begin_));
164 DCHECK(IsAligned<accounting::CardTable::kCardSize>(end_));
165 DCHECK(IsAligned<kPageSize>(begin_));
166 DCHECK(IsAligned<kPageSize>(end_));
167 size_t size = RoundUp(Size(), kPageSize);
Mathieu Chartier85a43c02014-01-07 17:59:00 -0800168 // Trimming the heap should be done by the caller since we may have invalidated the accounting
169 // stored in between objects.
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700170 // Remaining size is for the new alloc space.
171 const size_t growth_limit = growth_limit_ - size;
172 const size_t capacity = Capacity() - size;
173 VLOG(heap) << "Begin " << reinterpret_cast<const void*>(begin_) << "\n"
174 << "End " << reinterpret_cast<const void*>(end_) << "\n"
175 << "Size " << size << "\n"
176 << "GrowthLimit " << growth_limit_ << "\n"
177 << "Capacity " << Capacity();
178 SetGrowthLimit(RoundUp(size, kPageSize));
179 SetFootprintLimit(RoundUp(size, kPageSize));
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800180
181 // TODO: Not hardcode these in?
182 const size_t starting_size = kPageSize;
183 const size_t initial_size = 2 * MB;
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700184 // FIXME: Do we need reference counted pointers here?
185 // Make the two spaces share the same mark bitmaps since the bitmaps span both of the spaces.
186 VLOG(heap) << "Creating new AllocSpace: ";
187 VLOG(heap) << "Size " << GetMemMap()->Size();
188 VLOG(heap) << "GrowthLimit " << PrettySize(growth_limit);
189 VLOG(heap) << "Capacity " << PrettySize(capacity);
190 // Remap the tail.
191 std::string error_msg;
192 UniquePtr<MemMap> mem_map(GetMemMap()->RemapAtEnd(end_, alloc_space_name,
193 PROT_READ | PROT_WRITE, &error_msg));
194 CHECK(mem_map.get() != nullptr) << error_msg;
Hiroshi Yamauchi573f7d22013-12-17 11:54:23 -0800195 void* allocator = CreateAllocator(end_, starting_size, initial_size, low_memory_mode);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700196 // Protect memory beyond the initial size.
197 byte* end = mem_map->Begin() + starting_size;
198 if (capacity - initial_size > 0) {
199 CHECK_MEMORY_CALL(mprotect, (end, capacity - initial_size, PROT_NONE), alloc_space_name);
200 }
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800201 *out_malloc_space = CreateInstance(alloc_space_name, mem_map.release(), allocator, end_, end,
202 limit_, growth_limit);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700203 SetLimit(End());
204 live_bitmap_->SetHeapLimit(reinterpret_cast<uintptr_t>(End()));
205 CHECK_EQ(live_bitmap_->HeapLimit(), reinterpret_cast<uintptr_t>(End()));
206 mark_bitmap_->SetHeapLimit(reinterpret_cast<uintptr_t>(End()));
207 CHECK_EQ(mark_bitmap_->HeapLimit(), reinterpret_cast<uintptr_t>(End()));
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800208
209 // Create the actual zygote space.
210 ZygoteSpace* zygote_space = ZygoteSpace::Create("Zygote space", ReleaseMemMap(),
211 live_bitmap_.release(), mark_bitmap_.release());
212 if (UNLIKELY(zygote_space == nullptr)) {
213 VLOG(heap) << "Failed creating zygote space from space " << GetName();
214 } else {
215 VLOG(heap) << "zygote space creation done";
216 }
217 return zygote_space;
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700218}
219
220void MallocSpace::Dump(std::ostream& os) const {
221 os << GetType()
222 << " begin=" << reinterpret_cast<void*>(Begin())
223 << ",end=" << reinterpret_cast<void*>(End())
224 << ",size=" << PrettySize(Size()) << ",capacity=" << PrettySize(Capacity())
225 << ",name=\"" << GetName() << "\"]";
226}
227
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800228void MallocSpace::SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg) {
Mathieu Chartierec050072014-01-07 16:00:07 -0800229 SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800230 DCHECK(context->space->IsMallocSpace());
231 space::MallocSpace* space = context->space->AsMallocSpace();
Mathieu Chartierec050072014-01-07 16:00:07 -0800232 Thread* self = context->self;
233 Locks::heap_bitmap_lock_->AssertExclusiveHeld(self);
234 // If the bitmaps aren't swapped we need to clear the bits since the GC isn't going to re-swap
235 // the bitmaps as an optimization.
236 if (!context->swap_bitmaps) {
Mathieu Chartiera1602f22014-01-13 17:19:19 -0800237 accounting::SpaceBitmap* bitmap = space->GetLiveBitmap();
Mathieu Chartierec050072014-01-07 16:00:07 -0800238 for (size_t i = 0; i < num_ptrs; ++i) {
239 bitmap->Clear(ptrs[i]);
240 }
241 }
242 // Use a bulk free, that merges consecutive objects before freeing or free per object?
243 // Documentation suggests better free performance with merging, but this may be at the expensive
244 // of allocation.
245 context->freed_objects += num_ptrs;
246 context->freed_bytes += space->FreeList(self, num_ptrs, ptrs);
247}
248
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -0700249} // namespace space
250} // namespace gc
251} // namespace art