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_LIBARTBASE_BASE_ALLOCATOR_H_
18 #define ART_LIBARTBASE_BASE_ALLOCATOR_H_
19
20 #include <type_traits>
21
22 #include "atomic.h"
23 #include "macros.h"
24
25 namespace art {
26
27 static constexpr bool kEnableTrackingAllocator = false;
28
29 class Allocator {
30 public:
31 static Allocator* GetCallocAllocator();
32 static Allocator* GetNoopAllocator();
33
Allocator()34 Allocator() {}
~Allocator()35 virtual ~Allocator() {}
36
37 virtual void* Alloc(size_t) = 0;
38 virtual void Free(void*) = 0;
39
40 private:
41 DISALLOW_COPY_AND_ASSIGN(Allocator);
42 };
43
44 // Used by TrackedAllocators.
45 enum AllocatorTag {
46 kAllocatorTagHeap,
47 kAllocatorTagMonitorList,
48 kAllocatorTagClassTable,
49 kAllocatorTagInternTable,
50 kAllocatorTagMaps,
51 kAllocatorTagLOS,
52 kAllocatorTagSafeMap,
53 kAllocatorTagLOSMaps,
54 kAllocatorTagReferenceTable,
55 kAllocatorTagHeapBitmap,
56 kAllocatorTagHeapBitmapLOS,
57 kAllocatorTagMonitorPool,
58 kAllocatorTagLOSFreeList,
59 kAllocatorTagVerifier,
60 kAllocatorTagRememberedSet,
61 kAllocatorTagModUnionCardSet,
62 kAllocatorTagModUnionReferenceArray,
63 kAllocatorTagJNILibraries,
64 kAllocatorTagCompileTimeClassPath,
65 kAllocatorTagOatFile,
66 kAllocatorTagDexFileVerifier,
67 kAllocatorTagRosAlloc,
68 kAllocatorTagCount, // Must always be last element.
69 };
70 std::ostream& operator<<(std::ostream& os, AllocatorTag tag);
71
72 namespace TrackedAllocators {
73
74 // We use memory_order_relaxed updates of the following counters. Values are treated as approximate
75 // wherever concurrent updates are possible.
76 // Running count of number of bytes used for this kind of allocation. Increased by allocations,
77 // decreased by deallocations.
78 extern Atomic<size_t> g_bytes_used[kAllocatorTagCount];
79
80 // Largest value of bytes used seen.
81 extern Atomic<size_t> g_max_bytes_used[kAllocatorTagCount];
82
83 // Total number of bytes allocated of this kind.
84 extern Atomic<uint64_t> g_total_bytes_used[kAllocatorTagCount];
85
86 void Dump(std::ostream& os);
87
RegisterAllocation(AllocatorTag tag,size_t bytes)88 inline void RegisterAllocation(AllocatorTag tag, size_t bytes) {
89 g_total_bytes_used[tag].fetch_add(bytes, std::memory_order_relaxed);
90 size_t new_bytes = g_bytes_used[tag].fetch_add(bytes, std::memory_order_relaxed) + bytes;
91 size_t max_bytes = g_max_bytes_used[tag].load(std::memory_order_relaxed);
92 while (max_bytes < new_bytes
93 && !g_max_bytes_used[tag].compare_exchange_weak(max_bytes /* updated */, new_bytes,
94 std::memory_order_relaxed)) {
95 }
96 }
97
RegisterFree(AllocatorTag tag,size_t bytes)98 inline void RegisterFree(AllocatorTag tag, size_t bytes) {
99 g_bytes_used[tag].fetch_sub(bytes, std::memory_order_relaxed);
100 }
101
102 } // namespace TrackedAllocators
103
104 // Tracking allocator for use with STL types, tracks how much memory is used.
105 template <class T, AllocatorTag kTag>
106 class TrackingAllocatorImpl {
107 static_assert(kTag < kAllocatorTagCount, "kTag must be less than kAllocatorTagCount");
108
109 public:
110 using value_type = T;
111
112 // Used internally by STL data structures. This copy constructor needs to be implicit. Don't wrap
113 // the line because that would break cpplint's detection of the implicit constructor.
114 template <class U>
TrackingAllocatorImpl(const TrackingAllocatorImpl<U,kTag> & alloc)115 TrackingAllocatorImpl([[maybe_unused]] const TrackingAllocatorImpl<U, kTag>& alloc) noexcept {} // NOLINT [runtime/explicit]
116 // Used internally by STL data structures.
TrackingAllocatorImpl()117 TrackingAllocatorImpl() noexcept {}
118
119 // Enables an allocator for objects of one type to allocate storage for objects of another type.
120 // Used internally by STL data structures.
121 template <class U>
122 struct rebind {
123 using other = TrackingAllocatorImpl<U, kTag>;
124 };
125
allocate(size_t n)126 T* allocate(size_t n) {
127 const size_t size = n * sizeof(T);
128 TrackedAllocators::RegisterAllocation(GetTag(), size);
129 return reinterpret_cast<T*>(malloc(size));
130 }
131
deallocate(T * p,size_t n)132 void deallocate(T* p, size_t n) {
133 const size_t size = n * sizeof(T);
134 TrackedAllocators::RegisterFree(GetTag(), size);
135 free(p);
136 }
137
GetTag()138 static constexpr AllocatorTag GetTag() {
139 return kTag;
140 }
141 };
142
143 template<class T, AllocatorTag kTag>
144 using TrackingAllocator = std::conditional_t<kEnableTrackingAllocator,
145 TrackingAllocatorImpl<T, kTag>,
146 std::allocator<T>>;
147
148 } // namespace art
149
150 #endif // ART_LIBARTBASE_BASE_ALLOCATOR_H_
151