1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_RUNTIME_BASE_ALLOCATOR_H_
#define ART_RUNTIME_BASE_ALLOCATOR_H_
#include <map>
#include "atomic.h"
#include "base/macros.h"
#include "base/mutex.h"
#include "base/type_static_if.h"
namespace art {
static constexpr bool kEnableTrackingAllocator = false;
class Allocator {
public:
static Allocator* GetMallocAllocator();
static Allocator* GetNoopAllocator();
Allocator() {}
virtual ~Allocator() {}
virtual void* Alloc(size_t) = 0;
virtual void Free(void*) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(Allocator);
};
// Used by TrackedAllocators.
enum AllocatorTag {
kAllocatorTagHeap,
kAllocatorTagMonitorList,
kAllocatorTagClassTable,
kAllocatorTagInternTable,
kAllocatorTagMaps,
kAllocatorTagLOS,
kAllocatorTagSafeMap,
kAllocatorTagLOSMaps,
kAllocatorTagReferenceTable,
kAllocatorTagHeapBitmap,
kAllocatorTagHeapBitmapLOS,
kAllocatorTagMonitorPool,
kAllocatorTagLOSFreeList,
kAllocatorTagVerifier,
kAllocatorTagRememberedSet,
kAllocatorTagModUnionCardSet,
kAllocatorTagModUnionReferenceArray,
kAllocatorTagJNILibrarires,
kAllocatorTagCompileTimeClassPath,
kAllocatorTagOatFile,
kAllocatorTagDexFileVerifier,
kAllocatorTagRosAlloc,
kAllocatorTagCount, // Must always be last element.
};
std::ostream& operator<<(std::ostream& os, const AllocatorTag& tag);
namespace TrackedAllocators {
// Running count of number of bytes used for this kind of allocation. Increased by allocations,
// decreased by deallocations.
extern Atomic<size_t> g_bytes_used[kAllocatorTagCount];
// Largest value of bytes used seen.
extern volatile size_t g_max_bytes_used[kAllocatorTagCount];
// Total number of bytes allocated of this kind.
extern Atomic<uint64_t> g_total_bytes_used[kAllocatorTagCount];
void Dump(std::ostream& os);
inline void RegisterAllocation(AllocatorTag tag, size_t bytes) {
g_total_bytes_used[tag].FetchAndAddSequentiallyConsistent(bytes);
size_t new_bytes = g_bytes_used[tag].FetchAndAddSequentiallyConsistent(bytes) + bytes;
if (g_max_bytes_used[tag] < new_bytes) {
g_max_bytes_used[tag] = new_bytes;
}
}
inline void RegisterFree(AllocatorTag tag, size_t bytes) {
g_bytes_used[tag].FetchAndSubSequentiallyConsistent(bytes);
}
} // namespace TrackedAllocators
// Tracking allocator for use with STL types, tracks how much memory is used.
template<class T, AllocatorTag kTag>
class TrackingAllocatorImpl {
public:
typedef typename std::allocator<T>::value_type value_type;
typedef typename std::allocator<T>::size_type size_type;
typedef typename std::allocator<T>::difference_type difference_type;
typedef typename std::allocator<T>::pointer pointer;
typedef typename std::allocator<T>::const_pointer const_pointer;
typedef typename std::allocator<T>::reference reference;
typedef typename std::allocator<T>::const_reference const_reference;
// Used internally by STL data structures.
template <class U>
TrackingAllocatorImpl(const TrackingAllocatorImpl<U, kTag>& alloc) throw() {
}
// Used internally by STL data structures.
TrackingAllocatorImpl() throw() {
COMPILE_ASSERT(kTag < kAllocatorTagCount, must_be_less_than_count);
}
// Enables an allocator for objects of one type to allocate storage for objects of another type.
// Used internally by STL data structures.
template <class U>
struct rebind {
typedef TrackingAllocatorImpl<U, kTag> other;
};
pointer allocate(size_type n, const_pointer hint = 0) {
const size_t size = n * sizeof(T);
TrackedAllocators::RegisterAllocation(GetTag(), size);
return reinterpret_cast<pointer>(malloc(size));
}
template <typename PT>
void deallocate(PT p, size_type n) {
const size_t size = n * sizeof(T);
TrackedAllocators::RegisterFree(GetTag(), size);
free(p);
}
static constexpr AllocatorTag GetTag() {
return kTag;
}
};
template<class T, AllocatorTag kTag>
// C++ doesn't allow template typedefs. This is a workaround template typedef which is
// TrackingAllocatorImpl<T> if kEnableTrackingAllocator is true, std::allocator<T> otherwise.
class TrackingAllocator : public TypeStaticIf<kEnableTrackingAllocator,
TrackingAllocatorImpl<T, kTag>,
std::allocator<T>>::type {
};
template<class Key, class T, AllocatorTag kTag, class Compare = std::less<Key>>
class AllocationTrackingMultiMap : public std::multimap<
Key, T, Compare, TrackingAllocator<std::pair<Key, T>, kTag>> {
};
template<class Key, AllocatorTag kTag, class Compare = std::less<Key>>
class AllocationTrackingSet : public std::set<Key, Compare, TrackingAllocator<Key, kTag>> {
};
} // namespace art
#endif // ART_RUNTIME_BASE_ALLOCATOR_H_
|
