HeapSource.h revision ef75d4667167f0a82a9d2ee3fe9afeecbc679b82 
1/*
2 * Copyright (C) 2008 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#ifndef _DALVIK_HEAP_SOURCE
17#define _DALVIK_HEAP_SOURCE
18
19#include "alloc/Heap.h"
20#include "alloc/HeapInternal.h" // for GcHeap
21
22/* dlmalloc uses one size_t per allocated chunk.
23 */
24#define HEAP_SOURCE_CHUNK_OVERHEAD         (1 * sizeof (size_t))
25#define HEAP_SOURCE_WORST_CHUNK_OVERHEAD   (32 * sizeof (size_t))
26
27/* The largest number of separate heaps we can handle.
28 */
29#define HEAP_SOURCE_MAX_HEAP_COUNT 2
30
31/*
32 * Initializes the heap source; must be called before any other
33 * dvmHeapSource*() functions.
34 */
35GcHeap *dvmHeapSourceStartup(size_t startSize, size_t absoluteMaxSize);
36
37/*
38 * If the HeapSource was created while in zygote mode, this
39 * will create a new heap for post-zygote allocations.
40 * Having a separate heap should maximize the number of pages
41 * that a given app_process shares with the zygote process.
42 */
43bool dvmHeapSourceStartupAfterZygote(void);
44
45/*
46 * If the HeapSource was created while in zygote mode, this
47 * will create an additional zygote heap before the first fork().
48 * Having a separate heap should reduce the number of shared
49 * pages subsequently touched by the zygote process.
50 */
51bool dvmHeapSourceStartupBeforeFork(void);
52
53/*
54 * Shutdown any threads internal to the heap source.  This should be
55 * called before the heap source itself is shutdown.
56 */
57void dvmHeapSourceThreadShutdown(void);
58
59/*
60 * Tears down the heap source and frees any resources associated with it.
61 */
62void dvmHeapSourceShutdown(GcHeap **gcHeap);
63
64/*
65 * Returns the base and inclusive max addresses of the heap source
66 * heaps.  The base and max values are suitable for passing directly
67 * to the bitmap sweeping routine.
68 */
69void dvmHeapSourceGetRegions(uintptr_t *base, uintptr_t *max, size_t numHeaps);
70
71/*
72 * Get the bitmap representing all live objects.
73 */
74HeapBitmap *dvmHeapSourceGetLiveBits(void);
75
76/*
77 * Get the bitmap representing all marked objects.
78 */
79HeapBitmap *dvmHeapSourceGetMarkBits(void);
80
81/*
82 * Gets the begining of the allocation for the HeapSource.
83 */
84void *dvmHeapSourceGetBase(void);
85
86/*
87 * Returns the requested value. If the per-heap stats are requested, fill
88 * them as well.
89 */
90enum HeapSourceValueSpec {
91    HS_FOOTPRINT,
92    HS_ALLOWED_FOOTPRINT,
93    HS_BYTES_ALLOCATED,
94    HS_OBJECTS_ALLOCATED,
95    HS_EXTERNAL_BYTES_ALLOCATED,
96    HS_EXTERNAL_LIMIT
97};
98size_t dvmHeapSourceGetValue(enum HeapSourceValueSpec spec,
99                             size_t perHeapStats[], size_t arrayLen);
100
101/*
102 * Allocates <n> bytes of zeroed data.
103 */
104void *dvmHeapSourceAlloc(size_t n);
105
106/*
107 * Allocates <n> bytes of zeroed data, growing up to absoluteMaxSize
108 * if necessary.
109 */
110void *dvmHeapSourceAllocAndGrow(size_t n);
111
112/*
113 * Frees the first numPtrs objects in the ptrs list and returns the
114 * amount of reclaimed storage.  The list must contain addresses all
115 * in the same mspace, and must be in increasing order. This implies
116 * that there are no duplicates, and no entries are NULL.
117 */
118size_t dvmHeapSourceFreeList(size_t numPtrs, void **ptrs);
119
120/*
121 * Returns true iff <ptr> was allocated from the heap source.
122 */
123bool dvmHeapSourceContains(const void *ptr);
124
125/*
126 * Returns true iff <ptr> is within the address space managed by heap source.
127 */
128bool dvmHeapSourceContainsAddress(const void *ptr);
129
130/*
131 * Returns the value of the requested flag.
132 */
133enum HeapSourcePtrFlag {
134    HS_CONTAINS,    // identical to dvmHeapSourceContains()
135    HS_ALLOCATED_IN_ZYGOTE
136};
137bool dvmHeapSourceGetPtrFlag(const void *ptr, enum HeapSourcePtrFlag flag);
138
139/*
140 * Returns the number of usable bytes in an allocated chunk; the size
141 * may be larger than the size passed to dvmHeapSourceAlloc().
142 */
143size_t dvmHeapSourceChunkSize(const void *ptr);
144
145/*
146 * Returns the number of bytes that the heap source has allocated
147 * from the system using sbrk/mmap, etc.
148 */
149size_t dvmHeapSourceFootprint(void);
150
151/*
152 * Gets the maximum number of bytes that the heap source is allowed
153 * to allocate from the system.
154 */
155size_t dvmHeapSourceGetIdealFootprint(void);
156
157/*
158 * Given the current contents of the heap, increase the allowed
159 * heap footprint to match the target utilization ratio.  This
160 * should only be called immediately after a full mark/sweep.
161 */
162void dvmHeapSourceGrowForUtilization(void);
163
164/*
165 * Return unused memory to the system if possible.  If <bytesTrimmed>
166 * is non-NULL, the number of bytes returned to the system is written to it.
167 */
168void dvmHeapSourceTrim(size_t bytesTrimmed[], size_t arrayLen);
169
170/*
171 * Walks over the heap source and passes every allocated and
172 * free chunk to the callback.
173 */
174void dvmHeapSourceWalk(void(*callback)(const void *chunkptr, size_t chunklen,
175                                      const void *userptr, size_t userlen,
176                                      void *arg),
177                       void *arg);
178/*
179 * Gets the number of heaps available in the heap source.
180 */
181size_t dvmHeapSourceGetNumHeaps(void);
182
183/*
184 * Exchanges the mark and object bitmaps.
185 */
186void dvmHeapSourceSwapBitmaps(void);
187
188/*
189 * Zeroes the mark bitmap.
190 */
191void dvmHeapSourceZeroMarkBitmap(void);
192
193/*
194 * Marks all objects inside the immune region of the heap. Addresses
195 * at or above this pointer are threatened, addresses below this
196 * pointer are immune.
197 */
198void dvmMarkImmuneObjects(const char *immuneLimit);
199
200/*
201 * Returns a pointer that demarcates the threatened region of the
202 * heap.  Addresses at or above this pointer are threatened, addresses
203 * below this pointer are immune.
204 */
205void *dvmHeapSourceGetImmuneLimit(GcMode mode);
206
207#endif  // _DALVIK_HEAP_SOURCE
208