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