dlmalloc_space.h revision 654dd48e2230e16bfaa225decce72b52642e2f78 
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
17#ifndef ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_
18#define ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_
19
20#include "malloc_space.h"
21#include "space.h"
22
23namespace art {
24namespace gc {
25
26namespace collector {
27  class MarkSweep;
28}  // namespace collector
29
30namespace space {
31
32// An alloc space is a space where objects may be allocated and garbage collected. Not final as may
33// be overridden by a ValgrindMallocSpace.
34class DlMallocSpace : public MallocSpace {
35 public:
36  // Create a DlMallocSpace from an existing mem_map.
37  static DlMallocSpace* CreateFromMemMap(MemMap* mem_map, const std::string& name,
38                                         size_t starting_size, size_t initial_size,
39                                         size_t growth_limit, size_t capacity,
40                                         bool can_move_objects);
41
42  // Create a DlMallocSpace with the requested sizes. The requested
43  // base address is not guaranteed to be granted, if it is required,
44  // the caller should call Begin on the returned space to confirm the
45  // request was granted.
46  static DlMallocSpace* Create(const std::string& name, size_t initial_size, size_t growth_limit,
47                               size_t capacity, byte* requested_begin, bool can_move_objects);
48
49  // Virtual to allow ValgrindMallocSpace to intercept.
50  virtual mirror::Object* AllocWithGrowth(Thread* self, size_t num_bytes, size_t* bytes_allocated,
51                                          size_t* usable_size) OVERRIDE LOCKS_EXCLUDED(lock_);
52  // Virtual to allow ValgrindMallocSpace to intercept.
53  virtual mirror::Object* Alloc(Thread* self, size_t num_bytes, size_t* bytes_allocated,
54                        size_t* usable_size) OVERRIDE LOCKS_EXCLUDED(lock_) {
55    return AllocNonvirtual(self, num_bytes, bytes_allocated, usable_size);
56  }
57  // Virtual to allow ValgrindMallocSpace to intercept.
58  virtual size_t AllocationSize(mirror::Object* obj, size_t* usable_size) OVERRIDE {
59    return AllocationSizeNonvirtual(obj, usable_size);
60  }
61  // Virtual to allow ValgrindMallocSpace to intercept.
62  virtual size_t Free(Thread* self, mirror::Object* ptr) OVERRIDE
63      LOCKS_EXCLUDED(lock_)
64      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
65  // Virtual to allow ValgrindMallocSpace to intercept.
66  virtual size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) OVERRIDE
67      LOCKS_EXCLUDED(lock_)
68      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
69
70  // DlMallocSpaces don't have thread local state.
71  void RevokeThreadLocalBuffers(art::Thread*) OVERRIDE {
72  }
73  void RevokeAllThreadLocalBuffers() OVERRIDE {
74  }
75
76  // Faster non-virtual allocation path.
77  mirror::Object* AllocNonvirtual(Thread* self, size_t num_bytes, size_t* bytes_allocated,
78                                  size_t* usable_size) LOCKS_EXCLUDED(lock_);
79
80  // Faster non-virtual allocation size path.
81  size_t AllocationSizeNonvirtual(mirror::Object* obj, size_t* usable_size);
82
83#ifndef NDEBUG
84  // Override only in the debug build.
85  void CheckMoreCoreForPrecondition();
86#endif
87
88  void* GetMspace() const {
89    return mspace_;
90  }
91
92  size_t Trim() OVERRIDE;
93
94  // Perform a mspace_inspect_all which calls back for each allocation chunk. The chunk may not be
95  // in use, indicated by num_bytes equaling zero.
96  void Walk(WalkCallback callback, void* arg) OVERRIDE LOCKS_EXCLUDED(lock_);
97
98  // Returns the number of bytes that the space has currently obtained from the system. This is
99  // greater or equal to the amount of live data in the space.
100  size_t GetFootprint() OVERRIDE;
101
102  // Returns the number of bytes that the heap is allowed to obtain from the system via MoreCore.
103  size_t GetFootprintLimit() OVERRIDE;
104
105  // Set the maximum number of bytes that the heap is allowed to obtain from the system via
106  // MoreCore. Note this is used to stop the mspace growing beyond the limit to Capacity. When
107  // allocations fail we GC before increasing the footprint limit and allowing the mspace to grow.
108  void SetFootprintLimit(size_t limit) OVERRIDE;
109
110  MallocSpace* CreateInstance(const std::string& name, MemMap* mem_map, void* allocator,
111                              byte* begin, byte* end, byte* limit, size_t growth_limit,
112                              bool can_move_objects);
113
114  uint64_t GetBytesAllocated() OVERRIDE;
115  uint64_t GetObjectsAllocated() OVERRIDE;
116
117  virtual void Clear() OVERRIDE;
118
119  bool IsDlMallocSpace() const OVERRIDE {
120    return true;
121  }
122
123  DlMallocSpace* AsDlMallocSpace() OVERRIDE {
124    return this;
125  }
126
127  void LogFragmentationAllocFailure(std::ostream& os, size_t failed_alloc_bytes) OVERRIDE
128      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
129
130 protected:
131  DlMallocSpace(const std::string& name, MemMap* mem_map, void* mspace, byte* begin, byte* end,
132                byte* limit, size_t growth_limit, bool can_move_objects, size_t starting_size,
133                size_t initial_size);
134
135 private:
136  mirror::Object* AllocWithoutGrowthLocked(Thread* self, size_t num_bytes, size_t* bytes_allocated,
137                                           size_t* usable_size)
138      EXCLUSIVE_LOCKS_REQUIRED(lock_);
139
140  void* CreateAllocator(void* base, size_t morecore_start, size_t initial_size,
141                        size_t /*maximum_size*/, bool /*low_memory_mode*/) OVERRIDE {
142    return CreateMspace(base, morecore_start, initial_size);
143  }
144  static void* CreateMspace(void* base, size_t morecore_start, size_t initial_size);
145
146  // The boundary tag overhead.
147  static const size_t kChunkOverhead = kWordSize;
148
149  // Underlying malloc space.
150  void* mspace_;
151
152  friend class collector::MarkSweep;
153
154  DISALLOW_COPY_AND_ASSIGN(DlMallocSpace);
155};
156
157}  // namespace space
158}  // namespace gc
159}  // namespace art
160
161#endif  // ART_RUNTIME_GC_SPACE_DLMALLOC_SPACE_H_
162