Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 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 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_ |
| 18 | #define ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_ |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 19 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 20 | #include "malloc_space.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 21 | #include "space.h" |
| 22 | |
| 23 | namespace art { |
| 24 | namespace gc { |
| 25 | |
| 26 | namespace collector { |
Igor Murashkin | 2ffb703 | 2017-11-08 13:35:21 -0800 | [diff] [blame] | 27 | class MarkSweep; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 28 | } // namespace collector |
| 29 | |
| 30 | namespace space { |
| 31 | |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 32 | // An alloc space is a space where objects may be allocated and garbage collected. Not final as may |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 33 | // be overridden by a MemoryToolMallocSpace. |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 34 | class DlMallocSpace : public MallocSpace { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 35 | public: |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 36 | // Create a DlMallocSpace from an existing mem_map. |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 37 | static DlMallocSpace* CreateFromMemMap(MemMap&& mem_map, |
| 38 | const std::string& name, |
| 39 | size_t starting_size, |
| 40 | size_t initial_size, |
| 41 | size_t growth_limit, |
| 42 | size_t capacity, |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 43 | bool can_move_objects); |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 44 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 45 | // Create a DlMallocSpace with the requested sizes. The requested |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 46 | // base address is not guaranteed to be granted, if it is required, |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 47 | // the caller should call Begin on the returned space to confirm the |
| 48 | // request was granted. |
Vladimir Marko | 1130659 | 2018-10-26 14:22:59 +0100 | [diff] [blame] | 49 | static DlMallocSpace* Create(const std::string& name, |
| 50 | size_t initial_size, |
| 51 | size_t growth_limit, |
| 52 | size_t capacity, |
| 53 | bool can_move_objects); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 54 | |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 55 | // Virtual to allow MemoryToolMallocSpace to intercept. |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 56 | mirror::Object* AllocWithGrowth(Thread* self, |
| 57 | size_t num_bytes, |
| 58 | size_t* bytes_allocated, |
| 59 | size_t* usable_size, |
| 60 | size_t* bytes_tl_bulk_allocated) override REQUIRES(!lock_); |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 61 | // Virtual to allow MemoryToolMallocSpace to intercept. |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 62 | mirror::Object* Alloc(Thread* self, |
| 63 | size_t num_bytes, |
| 64 | size_t* bytes_allocated, |
| 65 | size_t* usable_size, |
| 66 | size_t* bytes_tl_bulk_allocated) override REQUIRES(!lock_) { |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 67 | return AllocNonvirtual(self, num_bytes, bytes_allocated, usable_size, |
| 68 | bytes_tl_bulk_allocated); |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 69 | } |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 70 | // Virtual to allow MemoryToolMallocSpace to intercept. |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 71 | size_t AllocationSize(mirror::Object* obj, size_t* usable_size) override { |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 72 | return AllocationSizeNonvirtual(obj, usable_size); |
| 73 | } |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 74 | // Virtual to allow MemoryToolMallocSpace to intercept. |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 75 | size_t Free(Thread* self, mirror::Object* ptr) override |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 76 | REQUIRES(!lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 77 | REQUIRES_SHARED(Locks::mutator_lock_); |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 78 | // Virtual to allow MemoryToolMallocSpace to intercept. |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 79 | size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) override |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 80 | REQUIRES(!lock_) |
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 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 83 | size_t MaxBytesBulkAllocatedFor(size_t num_bytes) override { |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 84 | return num_bytes; |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 85 | } |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 86 | |
| 87 | // DlMallocSpaces don't have thread local state. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 88 | size_t RevokeThreadLocalBuffers(art::Thread*) override { |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 89 | return 0U; |
| 90 | } |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 91 | size_t RevokeAllThreadLocalBuffers() override { |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 92 | return 0U; |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 93 | } |
| 94 | |
| 95 | // Faster non-virtual allocation path. |
| 96 | mirror::Object* AllocNonvirtual(Thread* self, size_t num_bytes, size_t* bytes_allocated, |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 97 | size_t* usable_size, size_t* bytes_tl_bulk_allocated) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 98 | REQUIRES(!lock_); |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 99 | |
| 100 | // Faster non-virtual allocation size path. |
| 101 | size_t AllocationSizeNonvirtual(mirror::Object* obj, size_t* usable_size); |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 102 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 103 | #ifndef NDEBUG |
| 104 | // Override only in the debug build. |
Yi Kong | 3940254 | 2019-03-24 02:47:16 -0700 | [diff] [blame^] | 105 | void CheckMoreCoreForPrecondition() override; |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 106 | #endif |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 107 | |
| 108 | void* GetMspace() const { |
| 109 | return mspace_; |
| 110 | } |
| 111 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 112 | size_t Trim() override; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 113 | |
| 114 | // Perform a mspace_inspect_all which calls back for each allocation chunk. The chunk may not be |
| 115 | // in use, indicated by num_bytes equaling zero. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 116 | void Walk(WalkCallback callback, void* arg) override REQUIRES(!lock_); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 117 | |
Hiroshi Yamauchi | 09b07a9 | 2013-07-15 13:17:06 -0700 | [diff] [blame] | 118 | // Returns the number of bytes that the space has currently obtained from the system. This is |
| 119 | // greater or equal to the amount of live data in the space. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 120 | size_t GetFootprint() override; |
Hiroshi Yamauchi | 09b07a9 | 2013-07-15 13:17:06 -0700 | [diff] [blame] | 121 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 122 | // Returns the number of bytes that the heap is allowed to obtain from the system via MoreCore. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 123 | size_t GetFootprintLimit() override; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 124 | |
| 125 | // Set the maximum number of bytes that the heap is allowed to obtain from the system via |
| 126 | // MoreCore. Note this is used to stop the mspace growing beyond the limit to Capacity. When |
| 127 | // allocations fail we GC before increasing the footprint limit and allowing the mspace to grow. |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 128 | void SetFootprintLimit(size_t limit) override; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 129 | |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 130 | MallocSpace* CreateInstance(MemMap&& mem_map, |
| 131 | const std::string& name, |
| 132 | void* allocator, |
| 133 | uint8_t* begin, |
| 134 | uint8_t* end, |
| 135 | uint8_t* limit, |
| 136 | size_t growth_limit, |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 137 | bool can_move_objects) override; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 138 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 139 | uint64_t GetBytesAllocated() override; |
| 140 | uint64_t GetObjectsAllocated() override; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 141 | |
Roland Levillain | f73caca | 2018-08-24 17:19:07 +0100 | [diff] [blame] | 142 | void Clear() override; |
Mathieu Chartier | 0f72e41 | 2013-09-06 16:40:01 -0700 | [diff] [blame] | 143 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 144 | bool IsDlMallocSpace() const override { |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 145 | return true; |
| 146 | } |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 147 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 148 | DlMallocSpace* AsDlMallocSpace() override { |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 149 | return this; |
| 150 | } |
| 151 | |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 152 | void LogFragmentationAllocFailure(std::ostream& os, size_t failed_alloc_bytes) override |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 153 | REQUIRES_SHARED(Locks::mutator_lock_); |
Hiroshi Yamauchi | 654dd48 | 2014-07-09 12:54:32 -0700 | [diff] [blame] | 154 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 155 | protected: |
Vladimir Marko | c34bebf | 2018-08-16 16:12:49 +0100 | [diff] [blame] | 156 | DlMallocSpace(MemMap&& mem_map, |
| 157 | size_t initial_size, |
| 158 | const std::string& name, |
| 159 | void* mspace, |
| 160 | uint8_t* begin, |
| 161 | uint8_t* end, |
| 162 | uint8_t* limit, |
| 163 | size_t growth_limit, |
| 164 | bool can_move_objects, |
| 165 | size_t starting_size); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 166 | |
| 167 | private: |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 168 | mirror::Object* AllocWithoutGrowthLocked(Thread* self, size_t num_bytes, size_t* bytes_allocated, |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 169 | size_t* usable_size, |
| 170 | size_t* bytes_tl_bulk_allocated) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 171 | REQUIRES(lock_); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 172 | |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 173 | void* CreateAllocator(void* base, size_t morecore_start, size_t initial_size, |
Roland Levillain | bbc6e7e | 2018-08-24 16:58:47 +0100 | [diff] [blame] | 174 | size_t /*maximum_size*/, bool /*low_memory_mode*/) override { |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 175 | return CreateMspace(base, morecore_start, initial_size); |
| 176 | } |
| 177 | static void* CreateMspace(void* base, size_t morecore_start, size_t initial_size); |
Mathieu Chartier | 0f72e41 | 2013-09-06 16:40:01 -0700 | [diff] [blame] | 178 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 179 | // The boundary tag overhead. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 180 | static const size_t kChunkOverhead = sizeof(intptr_t); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 181 | |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 182 | // Underlying malloc space. |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 183 | void* mspace_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 184 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 185 | friend class collector::MarkSweep; |
| 186 | |
| 187 | DISALLOW_COPY_AND_ASSIGN(DlMallocSpace); |
| 188 | }; |
| 189 | |
| 190 | } // namespace space |
| 191 | } // namespace gc |
| 192 | } // namespace art |
| 193 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 194 | #endif // ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_ |