bump_pointer_space.cc revision c93c530efc175954160c3834c93961a1a946a35a
1/* 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 "bump_pointer_space.h" 18#include "bump_pointer_space-inl.h" 19#include "mirror/object-inl.h" 20#include "mirror/class-inl.h" 21#include "thread_list.h" 22 23namespace art { 24namespace gc { 25namespace space { 26 27BumpPointerSpace* BumpPointerSpace::Create(const std::string& name, size_t capacity, 28 byte* requested_begin) { 29 capacity = RoundUp(capacity, kPageSize); 30 std::string error_msg; 31 UniquePtr<MemMap> mem_map(MemMap::MapAnonymous(name.c_str(), requested_begin, capacity, 32 PROT_READ | PROT_WRITE, true, &error_msg)); 33 if (mem_map.get() == nullptr) { 34 LOG(ERROR) << "Failed to allocate pages for alloc space (" << name << ") of size " 35 << PrettySize(capacity) << " with message " << error_msg; 36 return nullptr; 37 } 38 return new BumpPointerSpace(name, mem_map.release()); 39} 40 41BumpPointerSpace::BumpPointerSpace(const std::string& name, byte* begin, byte* limit) 42 : ContinuousMemMapAllocSpace(name, nullptr, begin, begin, limit, 43 kGcRetentionPolicyAlwaysCollect), 44 growth_end_(limit), 45 objects_allocated_(0), bytes_allocated_(0), 46 block_lock_("Block lock"), 47 main_block_size_(0), 48 num_blocks_(0) { 49} 50 51BumpPointerSpace::BumpPointerSpace(const std::string& name, MemMap* mem_map) 52 : ContinuousMemMapAllocSpace(name, mem_map, mem_map->Begin(), mem_map->Begin(), mem_map->End(), 53 kGcRetentionPolicyAlwaysCollect), 54 growth_end_(mem_map->End()), 55 objects_allocated_(0), bytes_allocated_(0), 56 block_lock_("Block lock"), 57 main_block_size_(0), 58 num_blocks_(0) { 59} 60 61void BumpPointerSpace::Clear() { 62 // Release the pages back to the operating system. 63 CHECK_NE(madvise(Begin(), Limit() - Begin(), MADV_DONTNEED), -1) << "madvise failed"; 64} 65 66void BumpPointerSpace::Reset() { 67 // Reset the end of the space back to the beginning, we move the end forward as we allocate 68 // objects. 69 SetEnd(Begin()); 70 objects_allocated_ = 0; 71 bytes_allocated_ = 0; 72 growth_end_ = Limit(); 73 { 74 MutexLock mu(Thread::Current(), block_lock_); 75 num_blocks_ = 0; 76 main_block_size_ = 0; 77 } 78} 79 80void BumpPointerSpace::Dump(std::ostream& os) const { 81 os << GetName() << " " 82 << reinterpret_cast<void*>(Begin()) << "-" << reinterpret_cast<void*>(End()) << " - " 83 << reinterpret_cast<void*>(Limit()); 84} 85 86mirror::Object* BumpPointerSpace::GetNextObject(mirror::Object* obj) { 87 const uintptr_t position = reinterpret_cast<uintptr_t>(obj) + obj->SizeOf(); 88 return reinterpret_cast<mirror::Object*>(RoundUp(position, kAlignment)); 89} 90 91void BumpPointerSpace::RevokeThreadLocalBuffers(Thread* thread) { 92 MutexLock mu(Thread::Current(), block_lock_); 93 RevokeThreadLocalBuffersLocked(thread); 94} 95 96void BumpPointerSpace::RevokeAllThreadLocalBuffers() { 97 Thread* self = Thread::Current(); 98 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 99 MutexLock mu2(self, *Locks::thread_list_lock_); 100 // TODO: Not do a copy of the thread list? 101 std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 102 for (Thread* thread : thread_list) { 103 RevokeThreadLocalBuffers(thread); 104 } 105} 106 107void BumpPointerSpace::AssertThreadLocalBuffersAreRevoked(Thread* thread) { 108 if (kIsDebugBuild) { 109 MutexLock mu(Thread::Current(), block_lock_); 110 DCHECK(!thread->HasTlab()); 111 } 112} 113 114void BumpPointerSpace::AssertAllThreadLocalBuffersAreRevoked() { 115 if (kIsDebugBuild) { 116 Thread* self = Thread::Current(); 117 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 118 MutexLock mu2(self, *Locks::thread_list_lock_); 119 // TODO: Not do a copy of the thread list? 120 std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 121 for (Thread* thread : thread_list) { 122 AssertThreadLocalBuffersAreRevoked(thread); 123 } 124 } 125} 126 127void BumpPointerSpace::UpdateMainBlock() { 128 DCHECK_EQ(num_blocks_, 0U); 129 main_block_size_ = Size(); 130} 131 132// Returns the start of the storage. 133byte* BumpPointerSpace::AllocBlock(size_t bytes) { 134 bytes = RoundUp(bytes, kAlignment); 135 if (!num_blocks_) { 136 UpdateMainBlock(); 137 } 138 byte* storage = reinterpret_cast<byte*>( 139 AllocNonvirtualWithoutAccounting(bytes + sizeof(BlockHeader))); 140 if (LIKELY(storage != nullptr)) { 141 BlockHeader* header = reinterpret_cast<BlockHeader*>(storage); 142 header->size_ = bytes; // Write out the block header. 143 storage += sizeof(BlockHeader); 144 ++num_blocks_; 145 } 146 return storage; 147} 148 149void BumpPointerSpace::Walk(ObjectCallback* callback, void* arg) { 150 byte* pos = Begin(); 151 byte* end = End(); 152 byte* main_end = pos; 153 { 154 MutexLock mu(Thread::Current(), block_lock_); 155 // If we have 0 blocks then we need to update the main header since we have bump pointer style 156 // allocation into an unbounded region (actually bounded by Capacity()). 157 if (num_blocks_ == 0) { 158 UpdateMainBlock(); 159 } 160 main_end = Begin() + main_block_size_; 161 if (num_blocks_ == 0) { 162 // We don't have any other blocks, this means someone else may be allocating into the main 163 // block. In this case, we don't want to try and visit the other blocks after the main block 164 // since these could actually be part of the main block. 165 end = main_end; 166 } 167 } 168 // Walk all of the objects in the main block first. 169 while (pos < main_end) { 170 mirror::Object* obj = reinterpret_cast<mirror::Object*>(pos); 171 if (obj->GetClass() == nullptr) { 172 // There is a race condition where a thread has just allocated an object but not set the 173 // class. We can't know the size of this object, so we don't visit it and exit the function 174 // since there is guaranteed to be not other blocks. 175 return; 176 } else { 177 callback(obj, arg); 178 pos = reinterpret_cast<byte*>(GetNextObject(obj)); 179 } 180 } 181 // Walk the other blocks (currently only TLABs). 182 while (pos < end) { 183 BlockHeader* header = reinterpret_cast<BlockHeader*>(pos); 184 size_t block_size = header->size_; 185 pos += sizeof(BlockHeader); // Skip the header so that we know where the objects 186 mirror::Object* obj = reinterpret_cast<mirror::Object*>(pos); 187 const mirror::Object* end = reinterpret_cast<const mirror::Object*>(pos + block_size); 188 CHECK_LE(reinterpret_cast<const byte*>(end), End()); 189 // We don't know how many objects are allocated in the current block. When we hit a null class 190 // assume its the end. TODO: Have a thread update the header when it flushes the block? 191 while (obj < end && obj->GetClass() != nullptr) { 192 callback(obj, arg); 193 obj = GetNextObject(obj); 194 } 195 pos += block_size; 196 } 197} 198 199accounting::SpaceBitmap::SweepCallback* BumpPointerSpace::GetSweepCallback() { 200 LOG(FATAL) << "Unimplemented"; 201 return nullptr; 202} 203 204uint64_t BumpPointerSpace::GetBytesAllocated() { 205 // Start out pre-determined amount (blocks which are not being allocated into). 206 uint64_t total = static_cast<uint64_t>(bytes_allocated_.Load()); 207 Thread* self = Thread::Current(); 208 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 209 MutexLock mu2(self, *Locks::thread_list_lock_); 210 std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 211 MutexLock mu3(Thread::Current(), block_lock_); 212 // If we don't have any blocks, we don't have any thread local buffers. This check is required 213 // since there can exist multiple bump pointer spaces which exist at the same time. 214 if (num_blocks_ > 0) { 215 for (Thread* thread : thread_list) { 216 total += thread->thread_local_pos_ - thread->thread_local_start_; 217 } 218 } 219 return total; 220} 221 222uint64_t BumpPointerSpace::GetObjectsAllocated() { 223 // Start out pre-determined amount (blocks which are not being allocated into). 224 uint64_t total = static_cast<uint64_t>(objects_allocated_.Load()); 225 Thread* self = Thread::Current(); 226 MutexLock mu(self, *Locks::runtime_shutdown_lock_); 227 MutexLock mu2(self, *Locks::thread_list_lock_); 228 std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 229 MutexLock mu3(Thread::Current(), block_lock_); 230 // If we don't have any blocks, we don't have any thread local buffers. This check is required 231 // since there can exist multiple bump pointer spaces which exist at the same time. 232 if (num_blocks_ > 0) { 233 for (Thread* thread : thread_list) { 234 total += thread->thread_local_objects_; 235 } 236 } 237 return total; 238} 239 240void BumpPointerSpace::RevokeThreadLocalBuffersLocked(Thread* thread) { 241 objects_allocated_.FetchAndAdd(thread->thread_local_objects_); 242 bytes_allocated_.FetchAndAdd(thread->thread_local_pos_ - thread->thread_local_start_); 243 thread->SetTlab(nullptr, nullptr); 244} 245 246bool BumpPointerSpace::AllocNewTlab(Thread* self, size_t bytes) { 247 MutexLock mu(Thread::Current(), block_lock_); 248 RevokeThreadLocalBuffersLocked(self); 249 byte* start = AllocBlock(bytes); 250 if (start == nullptr) { 251 return false; 252 } 253 self->SetTlab(start, start + bytes); 254 return true; 255} 256 257} // namespace space 258} // namespace gc 259} // namespace art 260