1590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier/* 2590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * Copyright (C) 2013 The Android Open Source Project 3590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * 4590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * Licensed under the Apache License, Version 2.0 (the "License"); 5590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * you may not use this file except in compliance with the License. 6590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * You may obtain a copy of the License at 7590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * 8590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * http://www.apache.org/licenses/LICENSE-2.0 9590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * 10590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * Unless required by applicable law or agreed to in writing, software 11590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * distributed under the License is distributed on an "AS IS" BASIS, 12590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * See the License for the specific language governing permissions and 14590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier * limitations under the License. 15590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier */ 16590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 17590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier#include "bump_pointer_space.h" 18590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier#include "bump_pointer_space-inl.h" 19590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier#include "mirror/object-inl.h" 20590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier#include "mirror/class-inl.h" 21692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier#include "thread_list.h" 22590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 23590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiernamespace art { 24590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiernamespace gc { 25590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiernamespace space { 26590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 27590fee9e8972f872301c2d16a575d579ee564beeMathieu ChartierBumpPointerSpace* BumpPointerSpace::Create(const std::string& name, size_t capacity, 2813735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* requested_begin) { 29590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier capacity = RoundUp(capacity, kPageSize); 30590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier std::string error_msg; 31700a402244a1a423da4f3ba8032459f4b65fa18fIan Rogers std::unique_ptr<MemMap> mem_map(MemMap::MapAnonymous(name.c_str(), requested_begin, capacity, 325c42c29b89286e5efa4a4613132b09051ce5945bVladimir Marko PROT_READ | PROT_WRITE, true, false, 335c42c29b89286e5efa4a4613132b09051ce5945bVladimir Marko &error_msg)); 34590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier if (mem_map.get() == nullptr) { 35590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier LOG(ERROR) << "Failed to allocate pages for alloc space (" << name << ") of size " 36590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier << PrettySize(capacity) << " with message " << error_msg; 37590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return nullptr; 38590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier } 39590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return new BumpPointerSpace(name, mem_map.release()); 40590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 41590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 4231f441464c0c8f840aba37e236ad133f30308d70Mathieu ChartierBumpPointerSpace* BumpPointerSpace::CreateFromMemMap(const std::string& name, MemMap* mem_map) { 4331f441464c0c8f840aba37e236ad133f30308d70Mathieu Chartier return new BumpPointerSpace(name, mem_map); 4431f441464c0c8f840aba37e236ad133f30308d70Mathieu Chartier} 4531f441464c0c8f840aba37e236ad133f30308d70Mathieu Chartier 4613735955f39b3b304c37d2b2840663c131262c18Ian RogersBumpPointerSpace::BumpPointerSpace(const std::string& name, uint8_t* begin, uint8_t* limit) 47590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier : ContinuousMemMapAllocSpace(name, nullptr, begin, begin, limit, 48590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier kGcRetentionPolicyAlwaysCollect), 49692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier growth_end_(limit), 50692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier objects_allocated_(0), bytes_allocated_(0), 51692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier block_lock_("Block lock"), 52fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier main_block_size_(0), 53692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier num_blocks_(0) { 54590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 55590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 56590fee9e8972f872301c2d16a575d579ee564beeMathieu ChartierBumpPointerSpace::BumpPointerSpace(const std::string& name, MemMap* mem_map) 57590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier : ContinuousMemMapAllocSpace(name, mem_map, mem_map->Begin(), mem_map->Begin(), mem_map->End(), 58590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier kGcRetentionPolicyAlwaysCollect), 59692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier growth_end_(mem_map->End()), 60692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier objects_allocated_(0), bytes_allocated_(0), 612cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi block_lock_("Block lock", kBumpPointerSpaceBlockLock), 62fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier main_block_size_(0), 63692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier num_blocks_(0) { 64590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 65590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 66590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiervoid BumpPointerSpace::Clear() { 67590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Release the pages back to the operating system. 68c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers if (!kMadviseZeroes) { 69c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers memset(Begin(), 0, Limit() - Begin()); 70c5f17732d8144491c642776b6b48c85dfadf4b52Ian Rogers } 71590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier CHECK_NE(madvise(Begin(), Limit() - Begin(), MADV_DONTNEED), -1) << "madvise failed"; 72590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // Reset the end of the space back to the beginning, we move the end forward as we allocate 73590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier // objects. 74fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier SetEnd(Begin()); 753e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers objects_allocated_.StoreRelaxed(0); 763e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers bytes_allocated_.StoreRelaxed(0); 77590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier growth_end_ = Limit(); 78692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier { 79692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(Thread::Current(), block_lock_); 80692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier num_blocks_ = 0; 81fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier main_block_size_ = 0; 82692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 83590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 84590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 85590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiervoid BumpPointerSpace::Dump(std::ostream& os) const { 8615d3402bbf8265eb1165694da2e4117eb128f3bcMathieu Chartier os << GetName() << " " 8715d3402bbf8265eb1165694da2e4117eb128f3bcMathieu Chartier << reinterpret_cast<void*>(Begin()) << "-" << reinterpret_cast<void*>(End()) << " - " 8815d3402bbf8265eb1165694da2e4117eb128f3bcMathieu Chartier << reinterpret_cast<void*>(Limit()); 89590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 90590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 91590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartiermirror::Object* BumpPointerSpace::GetNextObject(mirror::Object* obj) { 92590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier const uintptr_t position = reinterpret_cast<uintptr_t>(obj) + obj->SizeOf(); 93590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier return reinterpret_cast<mirror::Object*>(RoundUp(position, kAlignment)); 94590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} 95590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier 964460a84be92b5a94ecfb5c650aef4945ab849c93Hiroshi Yamauchisize_t BumpPointerSpace::RevokeThreadLocalBuffers(Thread* thread) { 97692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(Thread::Current(), block_lock_); 98692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier RevokeThreadLocalBuffersLocked(thread); 994460a84be92b5a94ecfb5c650aef4945ab849c93Hiroshi Yamauchi return 0U; 100692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 101692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 1024460a84be92b5a94ecfb5c650aef4945ab849c93Hiroshi Yamauchisize_t BumpPointerSpace::RevokeAllThreadLocalBuffers() { 103692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier Thread* self = Thread::Current(); 104692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(self, *Locks::runtime_shutdown_lock_); 105692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu2(self, *Locks::thread_list_lock_); 106692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // TODO: Not do a copy of the thread list? 107692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 108692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier for (Thread* thread : thread_list) { 109692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier RevokeThreadLocalBuffers(thread); 110692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 1114460a84be92b5a94ecfb5c650aef4945ab849c93Hiroshi Yamauchi return 0U; 112692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 113692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 114c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchivoid BumpPointerSpace::AssertThreadLocalBuffersAreRevoked(Thread* thread) { 115c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi if (kIsDebugBuild) { 116c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi MutexLock mu(Thread::Current(), block_lock_); 117c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi DCHECK(!thread->HasTlab()); 118c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi } 119c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi} 120c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi 121c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchivoid BumpPointerSpace::AssertAllThreadLocalBuffersAreRevoked() { 122c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi if (kIsDebugBuild) { 123c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi Thread* self = Thread::Current(); 124c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi MutexLock mu(self, *Locks::runtime_shutdown_lock_); 125c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi MutexLock mu2(self, *Locks::thread_list_lock_); 126c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi // TODO: Not do a copy of the thread list? 127c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 128c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi for (Thread* thread : thread_list) { 129c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi AssertThreadLocalBuffersAreRevoked(thread); 130c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi } 131c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi } 132c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi} 133c93c530efc175954160c3834c93961a1a946a35aHiroshi Yamauchi 134692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartiervoid BumpPointerSpace::UpdateMainBlock() { 135692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier DCHECK_EQ(num_blocks_, 0U); 136fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier main_block_size_ = Size(); 137692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 138692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 139692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier// Returns the start of the storage. 14013735955f39b3b304c37d2b2840663c131262c18Ian Rogersuint8_t* BumpPointerSpace::AllocBlock(size_t bytes) { 141692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier bytes = RoundUp(bytes, kAlignment); 142692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (!num_blocks_) { 143692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier UpdateMainBlock(); 144692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 14513735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* storage = reinterpret_cast<uint8_t*>( 146692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier AllocNonvirtualWithoutAccounting(bytes + sizeof(BlockHeader))); 147692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (LIKELY(storage != nullptr)) { 148692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier BlockHeader* header = reinterpret_cast<BlockHeader*>(storage); 149692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier header->size_ = bytes; // Write out the block header. 150692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier storage += sizeof(BlockHeader); 151692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier ++num_blocks_; 152692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 153692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier return storage; 154692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 155692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 15683c8ee000d525017ead8753fce6bc1020249b96aMathieu Chartiervoid BumpPointerSpace::Walk(ObjectCallback* callback, void* arg) { 15713735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* pos = Begin(); 15813735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* end = End(); 15913735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* main_end = pos; 160692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier { 161692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(Thread::Current(), block_lock_); 162692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // If we have 0 blocks then we need to update the main header since we have bump pointer style 163692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // allocation into an unbounded region (actually bounded by Capacity()). 164692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (num_blocks_ == 0) { 165692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier UpdateMainBlock(); 166692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 1678544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier main_end = Begin() + main_block_size_; 1688544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier if (num_blocks_ == 0) { 1698544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // We don't have any other blocks, this means someone else may be allocating into the main 1708544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // block. In this case, we don't want to try and visit the other blocks after the main block 1718544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // since these could actually be part of the main block. 1728544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier end = main_end; 1738544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier } 174692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 175fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier // Walk all of the objects in the main block first. 176fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier while (pos < main_end) { 177fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier mirror::Object* obj = reinterpret_cast<mirror::Object*>(pos); 1782cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi // No read barrier because obj may not be a valid object. 1792cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi if (obj->GetClass<kDefaultVerifyFlags, kWithoutReadBarrier>() == nullptr) { 1808544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // There is a race condition where a thread has just allocated an object but not set the 1818544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // class. We can't know the size of this object, so we don't visit it and exit the function 1828544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier // since there is guaranteed to be not other blocks. 1838544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier return; 1848544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier } else { 1858544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier callback(obj, arg); 18613735955f39b3b304c37d2b2840663c131262c18Ian Rogers pos = reinterpret_cast<uint8_t*>(GetNextObject(obj)); 1878544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier } 188fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier } 189fc4c27e4d68707271bd7578ae5c8bef93a3ea66bMathieu Chartier // Walk the other blocks (currently only TLABs). 1908544b462b524a502d2a18efb5a790ef98fa5eb51Mathieu Chartier while (pos < end) { 191692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier BlockHeader* header = reinterpret_cast<BlockHeader*>(pos); 192692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier size_t block_size = header->size_; 193692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier pos += sizeof(BlockHeader); // Skip the header so that we know where the objects 194692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier mirror::Object* obj = reinterpret_cast<mirror::Object*>(pos); 195277ccbd200ea43590dfc06a93ae184a765327ad0Andreas Gampe const mirror::Object* end_obj = reinterpret_cast<const mirror::Object*>(pos + block_size); 196277ccbd200ea43590dfc06a93ae184a765327ad0Andreas Gampe CHECK_LE(reinterpret_cast<const uint8_t*>(end_obj), End()); 197692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // We don't know how many objects are allocated in the current block. When we hit a null class 198692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // assume its the end. TODO: Have a thread update the header when it flushes the block? 1992cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi // No read barrier because obj may not be a valid object. 2002cd334ae2d4287216523882f0d298cf3901b7ab1Hiroshi Yamauchi while (obj < end_obj && obj->GetClass<kDefaultVerifyFlags, kWithoutReadBarrier>() != nullptr) { 201692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier callback(obj, arg); 202692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier obj = GetNextObject(obj); 203692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 204692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier pos += block_size; 205692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 206692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 207692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 208a8e8f9c0a8e259a807d7b99a148d14104c24209dMathieu Chartieraccounting::ContinuousSpaceBitmap::SweepCallback* BumpPointerSpace::GetSweepCallback() { 2092c4257be8191c5eefde744e8965fcefc80a0a97dIan Rogers UNIMPLEMENTED(FATAL); 2102c4257be8191c5eefde744e8965fcefc80a0a97dIan Rogers UNREACHABLE(); 211692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 212692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 213692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartieruint64_t BumpPointerSpace::GetBytesAllocated() { 214692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // Start out pre-determined amount (blocks which are not being allocated into). 2153e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers uint64_t total = static_cast<uint64_t>(bytes_allocated_.LoadRelaxed()); 216692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier Thread* self = Thread::Current(); 217692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(self, *Locks::runtime_shutdown_lock_); 218692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu2(self, *Locks::thread_list_lock_); 219692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 220692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu3(Thread::Current(), block_lock_); 221692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // If we don't have any blocks, we don't have any thread local buffers. This check is required 222692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // since there can exist multiple bump pointer spaces which exist at the same time. 223692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (num_blocks_ > 0) { 224692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier for (Thread* thread : thread_list) { 225dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers total += thread->GetThreadLocalBytesAllocated(); 226692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 227692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 228692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier return total; 229692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 230692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 231692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartieruint64_t BumpPointerSpace::GetObjectsAllocated() { 232692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // Start out pre-determined amount (blocks which are not being allocated into). 2333e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers uint64_t total = static_cast<uint64_t>(objects_allocated_.LoadRelaxed()); 234692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier Thread* self = Thread::Current(); 235692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(self, *Locks::runtime_shutdown_lock_); 236692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu2(self, *Locks::thread_list_lock_); 237692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier std::list<Thread*> thread_list = Runtime::Current()->GetThreadList()->GetList(); 238692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu3(Thread::Current(), block_lock_); 239692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // If we don't have any blocks, we don't have any thread local buffers. This check is required 240692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier // since there can exist multiple bump pointer spaces which exist at the same time. 241692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (num_blocks_ > 0) { 242692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier for (Thread* thread : thread_list) { 243dd7624d2b9e599d57762d12031b10b89defc9807Ian Rogers total += thread->GetThreadLocalObjectsAllocated(); 244692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 245692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 246692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier return total; 247692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 248692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 249692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartiervoid BumpPointerSpace::RevokeThreadLocalBuffersLocked(Thread* thread) { 2503e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers objects_allocated_.FetchAndAddSequentiallyConsistent(thread->GetThreadLocalObjectsAllocated()); 2513e5cf305db800b2989ad57b7cde8fb3cc9fa1b9eIan Rogers bytes_allocated_.FetchAndAddSequentiallyConsistent(thread->GetThreadLocalBytesAllocated()); 252e6da9af8dfe0a3e3fbc2be700554f6478380e7b9Mathieu Chartier thread->SetTlab(nullptr, nullptr); 253692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 254692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 255e6da9af8dfe0a3e3fbc2be700554f6478380e7b9Mathieu Chartierbool BumpPointerSpace::AllocNewTlab(Thread* self, size_t bytes) { 256692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier MutexLock mu(Thread::Current(), block_lock_); 257692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier RevokeThreadLocalBuffersLocked(self); 25813735955f39b3b304c37d2b2840663c131262c18Ian Rogers uint8_t* start = AllocBlock(bytes); 259692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier if (start == nullptr) { 260692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier return false; 261692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier } 262e6da9af8dfe0a3e3fbc2be700554f6478380e7b9Mathieu Chartier self->SetTlab(start, start + bytes); 263692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier return true; 264692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier} 265692fafd9778141fa6ef0048c9569abd7ee0253bfMathieu Chartier 266b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartiervoid BumpPointerSpace::LogFragmentationAllocFailure(std::ostream& os, 267b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier size_t /* failed_alloc_bytes */) { 268b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier size_t max_contiguous_allocation = Limit() - End(); 269b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier os << "; failed due to fragmentation (largest possible contiguous allocation " 270b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier << max_contiguous_allocation << " bytes)"; 271b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier // Caller's job to print failed_alloc_bytes. 272b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier} 273b363f666883860d40823d5528df3c98c897f74f4Mathieu Chartier 274590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} // namespace space 275590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} // namespace gc 276590fee9e8972f872301c2d16a575d579ee564beeMathieu Chartier} // namespace art 277