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
|
/*
* Copyright (C) 2008 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.
*/
/*
* Garbage-collecting allocator.
*/
#ifndef _DALVIK_ALLOC_ALLOC
#define _DALVIK_ALLOC_ALLOC
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* Initialization.
*/
bool dvmGcStartup(void);
bool dvmCreateStockExceptions(void);
bool dvmGcStartupAfterZygote(void);
void dvmGcShutdown(void);
void dvmGcThreadShutdown(void);
bool dvmGcStartupClasses(void);
/*
* Do any last-minute preparation before we call fork() for the first time.
*/
bool dvmGcPreZygoteFork(void);
/*
* Basic allocation function.
*
* The new object will be added to the "tracked alloc" table unless
* flags is ALLOC_DONT_TRACK.
*
* Returns NULL and throws an exception on failure.
*/
void* dvmMalloc(size_t size, int flags);
/*
* Allocate a new object.
*
* The new object will be added to the "tracked alloc" table unless
* flags is ALLOC_DONT_TRACK.
*
* Returns NULL and throws an exception on failure.
*/
Object* dvmAllocObject(ClassObject* clazz, int flags);
/* flags for dvmMalloc */
enum {
ALLOC_DEFAULT = 0x00,
ALLOC_DONT_TRACK = 0x01, /* don't add to internal tracking list */
};
/*
* Track an object reference that is currently only visible internally.
* This is called automatically by dvmMalloc() unless ALLOC_DONT_TRACK
* is set.
*
* The "self" argument is allowed as an optimization; it may be NULL.
*/
void dvmAddTrackedAlloc(Object* obj, Thread* self);
/*
* Remove an object from the internal tracking list.
*
* Does nothing if "obj" is NULL.
*
* The "self" argument is allowed as an optimization; it may be NULL.
*/
void dvmReleaseTrackedAlloc(Object* obj, Thread* self);
/*
* Returns true iff <obj> points to a valid allocated object.
*/
bool dvmIsValidObject(const Object* obj);
/*
* Create a copy of an object.
*
* Returns NULL and throws an exception on failure.
*/
Object* dvmCloneObject(Object* obj, int flags);
/*
* Make the object finalizable.
*/
void dvmSetFinalizable(Object* obj);
/*
* Determine the exact number of GC heap bytes used by an object. (Internal
* to heap code except for debugging.)
*/
size_t dvmObjectSizeInHeap(const Object* obj);
/*
* Gets the current ideal heap utilization, represented as a number
* between zero and one.
*/
float dvmGetTargetHeapUtilization(void);
/*
* Sets the new ideal heap utilization, represented as a number
* between zero and one.
*/
void dvmSetTargetHeapUtilization(float newTarget);
/*
* Initiate garbage collection.
*
* This usually happens automatically, but can also be caused by
* Runtime.gc().
*/
void dvmCollectGarbage(void);
/*
* Returns a count of the direct instances of a class.
*/
size_t dvmCountInstancesOfClass(const ClassObject *clazz);
/*
* Returns a count of the instances of a class and its subclasses.
*/
size_t dvmCountAssignableInstancesOfClass(const ClassObject *clazz);
/*
* Removes any growth limits from the heap.
*/
void dvmClearGrowthLimit(void);
/*
* Returns true if the address is within the bounds of the heap.
*/
bool dvmIsHeapAddress(void *address);
#ifdef __cplusplus
}
#endif
#endif /*_DALVIK_ALLOC_ALLOC*/
|
