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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
/*
* Copyright (C) 2007 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.
*/
package dalvik.system;
/**
* Provides an interface to VM-global, Dalvik-specific features.
* An application cannot create its own Runtime instance, and must obtain
* one from the getRuntime method.
*
* @hide
*/
public final class VMRuntime {
/**
* Holds the VMRuntime singleton.
*/
private static final VMRuntime THE_ONE = new VMRuntime();
private int targetSdkVersion;
/**
* Prevents this class from being instantiated.
*/
private VMRuntime() {
}
/**
* Returns the object that represents the VM instance's Dalvik-specific
* runtime environment.
*
* @return the runtime object
*/
public static VMRuntime getRuntime() {
return THE_ONE;
}
/**
* Returns a copy of the VM's command-line property settings.
* These are in the form "name=value" rather than "-Dname=value".
*/
public native String[] properties();
/**
* Returns the VM's boot class path.
*/
public native String bootClassPath();
/**
* Returns the VM's class path.
*/
public native String classPath();
/**
* Returns the VM's version.
*/
public native String vmVersion();
/**
* Returns the name of the shared library providing the VM implementation.
*/
public native String vmLibrary();
/**
* Gets the current ideal heap utilization, represented as a number
* between zero and one. After a GC happens, the Dalvik heap may
* be resized so that (size of live objects) / (size of heap) is
* equal to this number.
*
* @return the current ideal heap utilization
*/
public native float getTargetHeapUtilization();
/**
* Sets the current ideal heap utilization, represented as a number
* between zero and one. After a GC happens, the Dalvik heap may
* be resized so that (size of live objects) / (size of heap) is
* equal to this number.
*
* <p>This is only a hint to the garbage collector and may be ignored.
*
* @param newTarget the new suggested ideal heap utilization.
* This value may be adjusted internally.
* @return the previous ideal heap utilization
* @throws IllegalArgumentException if newTarget is <= 0.0 or >= 1.0
*/
public float setTargetHeapUtilization(float newTarget) {
if (newTarget <= 0.0f || newTarget >= 1.0f) {
throw new IllegalArgumentException(newTarget +
" out of range (0,1)");
}
/* Synchronize to make sure that only one thread gets
* a given "old" value if both update at the same time.
* Allows for reliable save-and-restore semantics.
*/
synchronized (this) {
float oldTarget = getTargetHeapUtilization();
nativeSetTargetHeapUtilization(newTarget);
return oldTarget;
}
}
/**
* Sets the target SDK version. Should only be called before the
* app starts to run, because it may change the VM's behavior in
* dangerous ways. Use 0 to mean "current" (since callers won't
* necessarily know the actual current SDK version, and the
* allocated version numbers start at 1), and 10000 to mean
* CUR_DEVELOPMENT.
*/
public synchronized void setTargetSdkVersion(int targetSdkVersion) {
this.targetSdkVersion = targetSdkVersion;
setTargetSdkVersionNative(this.targetSdkVersion);
}
/**
* Gets the target SDK version. See {@link #setTargetSdkVersion} for
* special values.
*/
public synchronized int getTargetSdkVersion() {
return targetSdkVersion;
}
private native void setTargetSdkVersionNative(int targetSdkVersion);
/**
* This method exists for binary compatibility. It was part of a
* heap sizing API which was removed in Android 3.0 (Honeycomb).
*/
@Deprecated
public long getMinimumHeapSize() {
return 0;
}
/**
* This method exists for binary compatibility. It was part of a
* heap sizing API which was removed in Android 3.0 (Honeycomb).
*/
@Deprecated
public long setMinimumHeapSize(long size) {
return 0;
}
/**
* This method exists for binary compatibility. It used to
* perform a garbage collection that cleared SoftReferences.
*/
@Deprecated
public void gcSoftReferences() {}
/**
* This method exists for binary compatibility. It is equivalent
* to {@link System#runFinalization}.
*/
@Deprecated
public void runFinalizationSync() {
System.runFinalization();
}
/**
* Implements setTargetHeapUtilization().
*
* @param newTarget the new suggested ideal heap utilization.
* This value may be adjusted internally.
*/
private native void nativeSetTargetHeapUtilization(float newTarget);
/**
* This method exists for binary compatibility. It was part of
* the external allocation API which was removed in Android 3.0 (Honeycomb).
*/
@Deprecated
public boolean trackExternalAllocation(long size) {
return true;
}
/**
* This method exists for binary compatibility. It was part of
* the external allocation API which was removed in Android 3.0 (Honeycomb).
*/
@Deprecated
public void trackExternalFree(long size) {}
/**
* This method exists for binary compatibility. It was part of
* the external allocation API which was removed in Android 3.0 (Honeycomb).
*/
@Deprecated
public long getExternalBytesAllocated() {
return 0;
}
/**
* Tells the VM to enable the JIT compiler. If the VM does not have a JIT
* implementation, calling this method should have no effect.
*/
public native void startJitCompilation();
/**
* Tells the VM to disable the JIT compiler. If the VM does not have a JIT
* implementation, calling this method should have no effect.
*/
public native void disableJitCompilation();
/**
* Returns an array allocated in an area of the Java heap where it will never be moved.
* This is used to implement native allocations on the Java heap, such as DirectByteBuffers
* and Bitmaps.
*/
public native Object newNonMovableArray(Class<?> componentType, int length);
/**
* Returns the address of array[0]. This differs from using JNI in that JNI might lie and
* give you the address of a copy of the array when in forcecopy mode.
*/
public native long addressOf(Object array);
/**
* Removes any growth limits, allowing the application to allocate
* up to the maximum heap size.
*/
public native void clearGrowthLimit();
/**
* Returns true if either a Java debugger or native debugger is active.
*/
public native boolean isDebuggerActive();
/**
* Registers a native allocation so that the heap knows about it and performs GC as required.
* If the number of native allocated bytes exceeds the native allocation watermark, the
* function requests a concurrent GC. If the native bytes allocated exceeds a second higher
* watermark, it is determined that the application is registering native allocations at an
* unusually high rate and a GC is performed inside of the function to prevent memory usage
* from excessively increasing.
*/
public native void registerNativeAllocation(int bytes);
/**
* Registers a native free by reducing the number of native bytes accounted for.
*/
public native void registerNativeFree(int bytes);
/**
* Fill in dex caches with classes, fields, and methods that are
* already loaded. Typically used after Zygote preloading.
*/
public native void preloadDexCaches();
}
|