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       REQUIRES_SHARED(Locks::mutator_lock_) = 0;
67   virtual size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs)
68       REQUIRES_SHARED(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       REQUIRES_SHARED(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       REQUIRES_SHARED(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