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_MALLOC_SPACE_H_ 18 #define ART_RUNTIME_GC_SPACE_MALLOC_SPACE_H_ 19 20 #include "space.h" 21 22 #include <ostream> 23 #include "base/memory_tool.h" 24 25 namespace art { 26 namespace gc { 27 28 namespace collector { 29 class MarkSweep; 30 } // namespace collector 31 32 namespace space { 33 34 class ZygoteSpace; 35 36 // TODO: Remove define macro 37 #define CHECK_MEMORY_CALL(call, args, what) \ 38 do { \ 39 int rc = call args; \ 40 if (UNLIKELY(rc != 0)) { \ 41 errno = rc; \ 42 PLOG(FATAL) << # call << " failed for " << what; \ 43 } \ 44 } while (false) 45 46 // A common parent of DlMallocSpace and RosAllocSpace. 47 class MallocSpace : public ContinuousMemMapAllocSpace { 48 public: 49 typedef void(*WalkCallback)(void *start, void *end, size_t num_bytes, void* callback_arg); 50 GetType()51 SpaceType GetType() const { 52 return kSpaceTypeMallocSpace; 53 } 54 55 // Allocate num_bytes allowing the underlying space to grow. 56 virtual mirror::Object* AllocWithGrowth(Thread* self, size_t num_bytes, 57 size_t* bytes_allocated, size_t* usable_size, 58 size_t* bytes_tl_bulk_allocated) = 0; 59 // Allocate num_bytes without allowing the underlying space to grow. 60 virtual mirror::Object* Alloc(Thread* self, size_t num_bytes, size_t* bytes_allocated, 61 size_t* usable_size, size_t* bytes_tl_bulk_allocated) = 0; 62 // Return the storage space required by obj. If usable_size isn't null then it is set to the 63 // amount of the storage space that may be used by obj. 64 virtual size_t AllocationSize(mirror::Object* obj, size_t* usable_size) = 0; 65 virtual size_t Free(Thread* self, mirror::Object* ptr) 66 SHARED_REQUIRES(Locks::mutator_lock_) = 0; 67 virtual size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) 68 SHARED_REQUIRES(Locks::mutator_lock_) = 0; 69 70 // Returns the maximum bytes that could be allocated for the given 71 // size in bulk, that is the maximum value for the 72 // bytes_allocated_bulk out param returned by MallocSpace::Alloc(). 73 virtual size_t MaxBytesBulkAllocatedFor(size_t num_bytes) = 0; 74 75 #ifndef NDEBUG CheckMoreCoreForPrecondition()76 virtual void CheckMoreCoreForPrecondition() {} // to be overridden in the debug build. 77 #else CheckMoreCoreForPrecondition()78 void CheckMoreCoreForPrecondition() {} // no-op in the non-debug build. 79 #endif 80 81 void* MoreCore(intptr_t increment); 82 83 // Hands unused pages back to the system. 84 virtual size_t Trim() = 0; 85 86 // Perform a mspace_inspect_all which calls back for each allocation chunk. The chunk may not be 87 // in use, indicated by num_bytes equaling zero. 88 virtual void Walk(WalkCallback callback, void* arg) = 0; 89 90 // Returns the number of bytes that the space has currently obtained from the system. This is 91 // greater or equal to the amount of live data in the space. 92 virtual size_t GetFootprint() = 0; 93 94 // Returns the number of bytes that the heap is allowed to obtain from the system via MoreCore. 95 virtual size_t GetFootprintLimit() = 0; 96 97 // Set the maximum number of bytes that the heap is allowed to obtain from the system via 98 // MoreCore. Note this is used to stop the mspace growing beyond the limit to Capacity. When 99 // allocations fail we GC before increasing the footprint limit and allowing the mspace to grow. 100 virtual void SetFootprintLimit(size_t limit) = 0; 101 102 // Removes the fork time growth limit on capacity, allowing the application to allocate up to the 103 // maximum reserved size of the heap. ClearGrowthLimit()104 void ClearGrowthLimit() { 105 growth_limit_ = NonGrowthLimitCapacity(); 106 } 107 108 // Override capacity so that we only return the possibly limited capacity Capacity()109 size_t Capacity() const { 110 return growth_limit_; 111 } 112 113 // The total amount of memory reserved for the alloc space. NonGrowthLimitCapacity()114 size_t NonGrowthLimitCapacity() const { 115 return GetMemMap()->Size(); 116 } 117 118 // Change the non growth limit capacity by shrinking or expanding the map. Currently, only 119 // shrinking is supported. 120 void ClampGrowthLimit(); 121 122 void Dump(std::ostream& os) const; 123 124 void SetGrowthLimit(size_t growth_limit); 125 126 virtual MallocSpace* CreateInstance(MemMap* mem_map, const std::string& name, void* allocator, 127 uint8_t* begin, uint8_t* end, uint8_t* limit, 128 size_t growth_limit, bool can_move_objects) = 0; 129 130 // Splits ourself into a zygote space and new malloc space which has our unused memory. When true, 131 // the low memory mode argument specifies that the heap wishes the created space to be more 132 // aggressive in releasing unused pages. Invalidates the space its called on. 133 ZygoteSpace* CreateZygoteSpace(const char* alloc_space_name, bool low_memory_mode, 134 MallocSpace** out_malloc_space) NO_THREAD_SAFETY_ANALYSIS; 135 virtual uint64_t GetBytesAllocated() = 0; 136 virtual uint64_t GetObjectsAllocated() = 0; 137 138 // Returns the class of a recently freed object. 139 mirror::Class* FindRecentFreedObject(const mirror::Object* obj); 140 CanMoveObjects()141 bool CanMoveObjects() const OVERRIDE { 142 return can_move_objects_; 143 } 144 DisableMovingObjects()145 void DisableMovingObjects() { 146 can_move_objects_ = false; 147 } 148 149 protected: 150 MallocSpace(const std::string& name, MemMap* mem_map, uint8_t* begin, uint8_t* end, 151 uint8_t* limit, size_t growth_limit, bool create_bitmaps, bool can_move_objects, 152 size_t starting_size, size_t initial_size); 153 154 static MemMap* CreateMemMap(const std::string& name, size_t starting_size, size_t* initial_size, 155 size_t* growth_limit, size_t* capacity, uint8_t* requested_begin); 156 157 // When true the low memory mode argument specifies that the heap wishes the created allocator to 158 // be more aggressive in releasing unused pages. 159 virtual void* CreateAllocator(void* base, size_t morecore_start, size_t initial_size, 160 size_t maximum_size, bool low_memory_mode) = 0; 161 162 virtual void RegisterRecentFree(mirror::Object* ptr) 163 SHARED_REQUIRES(Locks::mutator_lock_) 164 REQUIRES(lock_); 165 GetSweepCallback()166 virtual accounting::ContinuousSpaceBitmap::SweepCallback* GetSweepCallback() { 167 return &SweepCallback; 168 } 169 170 // Recent allocation buffer. 171 static constexpr size_t kRecentFreeCount = kDebugSpaces ? (1 << 16) : 0; 172 static constexpr size_t kRecentFreeMask = kRecentFreeCount - 1; 173 std::pair<const mirror::Object*, mirror::Class*> recent_freed_objects_[kRecentFreeCount]; 174 size_t recent_free_pos_; 175 176 static size_t bitmap_index_; 177 178 // Used to ensure mutual exclusion when the allocation spaces data structures are being modified. 179 Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 180 181 // The capacity of the alloc space until such time that ClearGrowthLimit is called. 182 // The underlying mem_map_ controls the maximum size we allow the heap to grow to. The growth 183 // limit is a value <= to the mem_map_ capacity used for ergonomic reasons because of the zygote. 184 // Prior to forking the zygote the heap will have a maximally sized mem_map_ but the growth_limit_ 185 // will be set to a lower value. The growth_limit_ is used as the capacity of the alloc_space_, 186 // however, capacity normally can't vary. In the case of the growth_limit_ it can be cleared 187 // one time by a call to ClearGrowthLimit. 188 size_t growth_limit_; 189 190 // True if objects in the space are movable. 191 bool can_move_objects_; 192 193 // Starting and initial sized, used when you reset the space. 194 const size_t starting_size_; 195 const size_t initial_size_; 196 197 private: 198 static void SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg) 199 SHARED_REQUIRES(Locks::mutator_lock_); 200 201 DISALLOW_COPY_AND_ASSIGN(MallocSpace); 202 }; 203 204 } // namespace space 205 } // namespace gc 206 } // namespace art 207 208 #endif // ART_RUNTIME_GC_SPACE_MALLOC_SPACE_H_ 209