Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 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 | #ifndef ART_RUNTIME_GC_SPACE_BUMP_POINTER_SPACE_H_ |
| 18 | #define ART_RUNTIME_GC_SPACE_BUMP_POINTER_SPACE_H_ |
| 19 | |
| 20 | #include "space.h" |
| 21 | |
Andreas Gampe | 7fbc4a5 | 2018-11-28 08:26:47 -0800 | [diff] [blame] | 22 | #include "base/mutex.h" |
| 23 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 24 | namespace art { |
Andreas Gampe | 5d08fcc | 2017-06-05 17:56:46 -0700 | [diff] [blame] | 25 | |
| 26 | namespace mirror { |
| 27 | class Object; |
| 28 | } |
| 29 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 30 | namespace gc { |
| 31 | |
| 32 | namespace collector { |
Igor Murashkin | 2ffb703 | 2017-11-08 13:35:21 -0800 | [diff] [blame] | 33 | class MarkSweep; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 34 | } // namespace collector |
| 35 | |
| 36 | namespace space { |
| 37 | |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 38 | // A bump pointer space allocates by incrementing a pointer, it doesn't provide a free |
| 39 | // implementation as its intended to be evacuated. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 40 | class BumpPointerSpace final : public ContinuousMemMapAllocSpace { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 41 | public: |
| 42 | typedef void(*WalkCallback)(void *start, void *end, size_t num_bytes, void* callback_arg); |
| 43 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 44 | SpaceType GetType() const override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 45 | return kSpaceTypeBumpPointerSpace; |
| 46 | } |
| 47 | |
| 48 | // Create a bump pointer space with the requested sizes. The requested base address is not |
| 49 | // guaranteed to be granted, if it is required, the caller should call Begin on the returned |
| 50 | // space to confirm the request was granted. |
Vladimir Marko | 1130659 | 2018-10-26 14:22:59 +0100 | [diff] [blame] | 51 | static BumpPointerSpace* Create(const std::string& name, size_t capacity); |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 52 | static BumpPointerSpace* CreateFromMemMap(const std::string& name, MemMap&& mem_map); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 53 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 54 | // Allocate num_bytes, returns null if the space is full. |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 55 | mirror::Object* Alloc(Thread* self, size_t num_bytes, size_t* bytes_allocated, |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 56 | size_t* usable_size, size_t* bytes_tl_bulk_allocated) override; |
Mathieu Chartier | 0651d41 | 2014-04-29 14:37:57 -0700 | [diff] [blame] | 57 | // Thread-unsafe allocation for when mutators are suspended, used by the semispace collector. |
| 58 | mirror::Object* AllocThreadUnsafe(Thread* self, size_t num_bytes, size_t* bytes_allocated, |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 59 | size_t* usable_size, size_t* bytes_tl_bulk_allocated) |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 60 | override REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 0651d41 | 2014-04-29 14:37:57 -0700 | [diff] [blame] | 61 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 62 | mirror::Object* AllocNonvirtual(size_t num_bytes); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 63 | mirror::Object* AllocNonvirtualWithoutAccounting(size_t num_bytes); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 64 | |
| 65 | // Return the storage space required by obj. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 66 | size_t AllocationSize(mirror::Object* obj, size_t* usable_size) override |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 67 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 68 | return AllocationSizeNonvirtual(obj, usable_size); |
| 69 | } |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 70 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 71 | // NOPS unless we support free lists. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 72 | size_t Free(Thread*, mirror::Object*) override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 73 | return 0; |
| 74 | } |
| 75 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 76 | size_t FreeList(Thread*, size_t, mirror::Object**) override { |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 77 | return 0; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 78 | } |
| 79 | |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 80 | size_t AllocationSizeNonvirtual(mirror::Object* obj, size_t* usable_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 81 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 82 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 83 | // Removes the fork time growth limit on capacity, allowing the application to allocate up to the |
| 84 | // maximum reserved size of the heap. |
| 85 | void ClearGrowthLimit() { |
| 86 | growth_end_ = Limit(); |
| 87 | } |
| 88 | |
| 89 | // Override capacity so that we only return the possibly limited capacity |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 90 | size_t Capacity() const override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 91 | return growth_end_ - begin_; |
| 92 | } |
| 93 | |
| 94 | // The total amount of memory reserved for the space. |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 95 | size_t NonGrowthLimitCapacity() const override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 96 | return GetMemMap()->Size(); |
| 97 | } |
| 98 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 99 | accounting::ContinuousSpaceBitmap* GetLiveBitmap() const override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 100 | return nullptr; |
| 101 | } |
| 102 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 103 | accounting::ContinuousSpaceBitmap* GetMarkBitmap() const override { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 104 | return nullptr; |
| 105 | } |
| 106 | |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 107 | // Reset the space to empty. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 108 | void Clear() override REQUIRES(!block_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 109 | |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 110 | void Dump(std::ostream& os) const override; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 111 | |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 112 | size_t RevokeThreadLocalBuffers(Thread* thread) override REQUIRES(!block_lock_); |
| 113 | size_t RevokeAllThreadLocalBuffers() override |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 114 | REQUIRES(!Locks::runtime_shutdown_lock_, !Locks::thread_list_lock_, !block_lock_); |
| 115 | void AssertThreadLocalBuffersAreRevoked(Thread* thread) REQUIRES(!block_lock_); |
| 116 | void AssertAllThreadLocalBuffersAreRevoked() |
| 117 | REQUIRES(!Locks::runtime_shutdown_lock_, !Locks::thread_list_lock_, !block_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 118 | |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 119 | uint64_t GetBytesAllocated() override REQUIRES_SHARED(Locks::mutator_lock_) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 120 | REQUIRES(!*Locks::runtime_shutdown_lock_, !*Locks::thread_list_lock_, !block_lock_); |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 121 | uint64_t GetObjectsAllocated() override REQUIRES_SHARED(Locks::mutator_lock_) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 122 | REQUIRES(!*Locks::runtime_shutdown_lock_, !*Locks::thread_list_lock_, !block_lock_); |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 123 | bool IsEmpty() const { |
| 124 | return Begin() == End(); |
| 125 | } |
| 126 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 127 | bool CanMoveObjects() const override { |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 128 | return true; |
| 129 | } |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 130 | |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 131 | bool Contains(const mirror::Object* obj) const override { |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 132 | const uint8_t* byte_obj = reinterpret_cast<const uint8_t*>(obj); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 133 | return byte_obj >= Begin() && byte_obj < End(); |
| 134 | } |
| 135 | |
| 136 | // TODO: Change this? Mainly used for compacting to a particular region of memory. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 137 | BumpPointerSpace(const std::string& name, uint8_t* begin, uint8_t* limit); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 138 | |
| 139 | // Return the object which comes after obj, while ensuring alignment. |
| 140 | static mirror::Object* GetNextObject(mirror::Object* obj) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 141 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 142 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 143 | // Allocate a new TLAB, returns false if the allocation failed. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 144 | bool AllocNewTlab(Thread* self, size_t bytes) REQUIRES(!block_lock_); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 145 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 146 | BumpPointerSpace* AsBumpPointerSpace() override { |
Mathieu Chartier | 7410f29 | 2013-11-24 13:17:35 -0800 | [diff] [blame] | 147 | return this; |
| 148 | } |
| 149 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 150 | // Go through all of the blocks and visit the continuous objects. |
Andreas Gampe | 351c447 | 2017-07-12 19:32:55 -0700 | [diff] [blame] | 151 | template <typename Visitor> |
| 152 | ALWAYS_INLINE void Walk(Visitor&& visitor) |
Andreas Gampe | 0c18338 | 2017-07-13 22:26:24 -0700 | [diff] [blame] | 153 | REQUIRES_SHARED(Locks::mutator_lock_) |
| 154 | REQUIRES(!block_lock_); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 155 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 156 | accounting::ContinuousSpaceBitmap::SweepCallback* GetSweepCallback() override; |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 157 | |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 158 | // Record objects / bytes freed. |
| 159 | void RecordFree(int32_t objects, int32_t bytes) { |
Hans Boehm | fb8b4e2 | 2018-09-05 16:45:42 -0700 | [diff] [blame] | 160 | objects_allocated_.fetch_sub(objects, std::memory_order_relaxed); |
| 161 | bytes_allocated_.fetch_sub(bytes, std::memory_order_relaxed); |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 162 | } |
| 163 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 164 | void LogFragmentationAllocFailure(std::ostream& os, size_t failed_alloc_bytes) override |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 165 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | b363f66 | 2014-07-16 13:28:58 -0700 | [diff] [blame] | 166 | |
Mathieu Chartier | 7410f29 | 2013-11-24 13:17:35 -0800 | [diff] [blame] | 167 | // Object alignment within the space. |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 168 | static constexpr size_t kAlignment = 8; |
| 169 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 170 | protected: |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 171 | BumpPointerSpace(const std::string& name, MemMap&& mem_map); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 172 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 173 | // Allocate a raw block of bytes. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 174 | uint8_t* AllocBlock(size_t bytes) REQUIRES(block_lock_); |
| 175 | void RevokeThreadLocalBuffersLocked(Thread* thread) REQUIRES(block_lock_); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 176 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 177 | // The main block is an unbounded block where objects go when there are no other blocks. This |
| 178 | // enables us to maintain tightly packed objects when you are not using thread local buffers for |
Mathieu Chartier | fc4c27e | 2014-02-11 11:05:41 -0800 | [diff] [blame] | 179 | // allocation. The main block starts at the space Begin(). |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 180 | void UpdateMainBlock() REQUIRES(block_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 181 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 182 | uint8_t* growth_end_; |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 183 | AtomicInteger objects_allocated_; // Accumulated from revoked thread local regions. |
| 184 | AtomicInteger bytes_allocated_; // Accumulated from revoked thread local regions. |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 185 | Mutex block_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Mathieu Chartier | fc4c27e | 2014-02-11 11:05:41 -0800 | [diff] [blame] | 186 | // The objects at the start of the space are stored in the main block. The main block doesn't |
| 187 | // have a header, this lets us walk empty spaces which are mprotected. |
| 188 | size_t main_block_size_ GUARDED_BY(block_lock_); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 189 | // The number of blocks in the space, if it is 0 then the space has one long continuous block |
| 190 | // which doesn't have an updated header. |
| 191 | size_t num_blocks_ GUARDED_BY(block_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 192 | |
| 193 | private: |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 194 | struct BlockHeader { |
| 195 | size_t size_; // Size of the block in bytes, does not include the header. |
| 196 | size_t unused_; // Ensures alignment of kAlignment. |
| 197 | }; |
| 198 | |
Andreas Gampe | 575e78c | 2014-11-03 23:41:03 -0800 | [diff] [blame] | 199 | static_assert(sizeof(BlockHeader) % kAlignment == 0, |
| 200 | "continuous block must be kAlignment aligned"); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 201 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 202 | friend class collector::MarkSweep; |
| 203 | DISALLOW_COPY_AND_ASSIGN(BumpPointerSpace); |
| 204 | }; |
| 205 | |
| 206 | } // namespace space |
| 207 | } // namespace gc |
| 208 | } // namespace art |
| 209 | |
| 210 | #endif // ART_RUNTIME_GC_SPACE_BUMP_POINTER_SPACE_H_ |