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
17 #include "dalvik_system_VMDebug.h"
18
19 #include <string.h>
20 #include <unistd.h>
21
22 #include <sstream>
23
24 #include "base/histogram-inl.h"
25 #include "base/time_utils.h"
26 #include "class_linker.h"
27 #include "common_throws.h"
28 #include "debugger.h"
29 #include "gc/space/bump_pointer_space.h"
30 #include "gc/space/dlmalloc_space.h"
31 #include "gc/space/large_object_space.h"
32 #include "gc/space/space-inl.h"
33 #include "gc/space/zygote_space.h"
34 #include "hprof/hprof.h"
35 #include "jni_internal.h"
36 #include "mirror/class.h"
37 #include "ScopedLocalRef.h"
38 #include "ScopedUtfChars.h"
39 #include "scoped_fast_native_object_access.h"
40 #include "trace.h"
41 #include "well_known_classes.h"
42
43 namespace art {
44
VMDebug_getVmFeatureList(JNIEnv * env,jclass)45 static jobjectArray VMDebug_getVmFeatureList(JNIEnv* env, jclass) {
46 static const char* features[] = {
47 "method-trace-profiling",
48 "method-trace-profiling-streaming",
49 "method-sample-profiling",
50 "hprof-heap-dump",
51 "hprof-heap-dump-streaming",
52 };
53 jobjectArray result = env->NewObjectArray(arraysize(features),
54 WellKnownClasses::java_lang_String,
55 nullptr);
56 if (result != nullptr) {
57 for (size_t i = 0; i < arraysize(features); ++i) {
58 ScopedLocalRef<jstring> jfeature(env, env->NewStringUTF(features[i]));
59 if (jfeature.get() == nullptr) {
60 return nullptr;
61 }
62 env->SetObjectArrayElement(result, i, jfeature.get());
63 }
64 }
65 return result;
66 }
67
VMDebug_startAllocCounting(JNIEnv *,jclass)68 static void VMDebug_startAllocCounting(JNIEnv*, jclass) {
69 Runtime::Current()->SetStatsEnabled(true);
70 }
71
VMDebug_stopAllocCounting(JNIEnv *,jclass)72 static void VMDebug_stopAllocCounting(JNIEnv*, jclass) {
73 Runtime::Current()->SetStatsEnabled(false);
74 }
75
VMDebug_getAllocCount(JNIEnv *,jclass,jint kind)76 static jint VMDebug_getAllocCount(JNIEnv*, jclass, jint kind) {
77 return Runtime::Current()->GetStat(kind);
78 }
79
VMDebug_resetAllocCount(JNIEnv *,jclass,jint kinds)80 static void VMDebug_resetAllocCount(JNIEnv*, jclass, jint kinds) {
81 Runtime::Current()->ResetStats(kinds);
82 }
83
VMDebug_startMethodTracingDdmsImpl(JNIEnv *,jclass,jint bufferSize,jint flags,jboolean samplingEnabled,jint intervalUs)84 static void VMDebug_startMethodTracingDdmsImpl(JNIEnv*, jclass, jint bufferSize, jint flags,
85 jboolean samplingEnabled, jint intervalUs) {
86 Trace::Start("[DDMS]", -1, bufferSize, flags, Trace::TraceOutputMode::kDDMS,
87 samplingEnabled ? Trace::TraceMode::kSampling : Trace::TraceMode::kMethodTracing,
88 intervalUs);
89 }
90
VMDebug_startMethodTracingFd(JNIEnv * env,jclass,jstring javaTraceFilename,jobject javaFd,jint bufferSize,jint flags,jboolean samplingEnabled,jint intervalUs)91 static void VMDebug_startMethodTracingFd(JNIEnv* env, jclass, jstring javaTraceFilename,
92 jobject javaFd, jint bufferSize, jint flags,
93 jboolean samplingEnabled, jint intervalUs) {
94 int originalFd = jniGetFDFromFileDescriptor(env, javaFd);
95 if (originalFd < 0) {
96 return;
97 }
98
99 int fd = dup(originalFd);
100 if (fd < 0) {
101 ScopedObjectAccess soa(env);
102 soa.Self()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
103 "dup(%d) failed: %s", originalFd, strerror(errno));
104 return;
105 }
106
107 ScopedUtfChars traceFilename(env, javaTraceFilename);
108 if (traceFilename.c_str() == nullptr) {
109 return;
110 }
111 Trace::Start(traceFilename.c_str(), fd, bufferSize, flags, Trace::TraceOutputMode::kFile,
112 samplingEnabled ? Trace::TraceMode::kSampling : Trace::TraceMode::kMethodTracing,
113 intervalUs);
114 }
115
VMDebug_startMethodTracingFilename(JNIEnv * env,jclass,jstring javaTraceFilename,jint bufferSize,jint flags,jboolean samplingEnabled,jint intervalUs)116 static void VMDebug_startMethodTracingFilename(JNIEnv* env, jclass, jstring javaTraceFilename,
117 jint bufferSize, jint flags,
118 jboolean samplingEnabled, jint intervalUs) {
119 ScopedUtfChars traceFilename(env, javaTraceFilename);
120 if (traceFilename.c_str() == nullptr) {
121 return;
122 }
123 Trace::Start(traceFilename.c_str(), -1, bufferSize, flags, Trace::TraceOutputMode::kFile,
124 samplingEnabled ? Trace::TraceMode::kSampling : Trace::TraceMode::kMethodTracing,
125 intervalUs);
126 }
127
VMDebug_getMethodTracingMode(JNIEnv *,jclass)128 static jint VMDebug_getMethodTracingMode(JNIEnv*, jclass) {
129 return Trace::GetMethodTracingMode();
130 }
131
VMDebug_stopMethodTracing(JNIEnv *,jclass)132 static void VMDebug_stopMethodTracing(JNIEnv*, jclass) {
133 Trace::Stop();
134 }
135
VMDebug_startEmulatorTracing(JNIEnv *,jclass)136 static void VMDebug_startEmulatorTracing(JNIEnv*, jclass) {
137 UNIMPLEMENTED(WARNING);
138 // dvmEmulatorTraceStart();
139 }
140
VMDebug_stopEmulatorTracing(JNIEnv *,jclass)141 static void VMDebug_stopEmulatorTracing(JNIEnv*, jclass) {
142 UNIMPLEMENTED(WARNING);
143 // dvmEmulatorTraceStop();
144 }
145
VMDebug_isDebuggerConnected(JNIEnv *,jclass)146 static jboolean VMDebug_isDebuggerConnected(JNIEnv*, jclass) {
147 return Dbg::IsDebuggerActive();
148 }
149
VMDebug_isDebuggingEnabled(JNIEnv *,jclass)150 static jboolean VMDebug_isDebuggingEnabled(JNIEnv*, jclass) {
151 return Dbg::IsJdwpConfigured();
152 }
153
VMDebug_lastDebuggerActivity(JNIEnv *,jclass)154 static jlong VMDebug_lastDebuggerActivity(JNIEnv*, jclass) {
155 return Dbg::LastDebuggerActivity();
156 }
157
ThrowUnsupportedOperationException(JNIEnv * env)158 static void ThrowUnsupportedOperationException(JNIEnv* env) {
159 ScopedObjectAccess soa(env);
160 soa.Self()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", nullptr);
161 }
162
VMDebug_startInstructionCounting(JNIEnv * env,jclass)163 static void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
164 ThrowUnsupportedOperationException(env);
165 }
166
VMDebug_stopInstructionCounting(JNIEnv * env,jclass)167 static void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
168 ThrowUnsupportedOperationException(env);
169 }
170
VMDebug_getInstructionCount(JNIEnv * env,jclass,jintArray)171 static void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray /*javaCounts*/) {
172 ThrowUnsupportedOperationException(env);
173 }
174
VMDebug_resetInstructionCount(JNIEnv * env,jclass)175 static void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
176 ThrowUnsupportedOperationException(env);
177 }
178
VMDebug_printLoadedClasses(JNIEnv * env,jclass,jint flags)179 static void VMDebug_printLoadedClasses(JNIEnv* env, jclass, jint flags) {
180 ScopedFastNativeObjectAccess soa(env);
181 return Runtime::Current()->GetClassLinker()->DumpAllClasses(flags);
182 }
183
VMDebug_getLoadedClassCount(JNIEnv * env,jclass)184 static jint VMDebug_getLoadedClassCount(JNIEnv* env, jclass) {
185 ScopedFastNativeObjectAccess soa(env);
186 return Runtime::Current()->GetClassLinker()->NumLoadedClasses();
187 }
188
189 /*
190 * Returns the thread-specific CPU-time clock value for the current thread,
191 * or -1 if the feature isn't supported.
192 */
VMDebug_threadCpuTimeNanos(JNIEnv *,jclass)193 static jlong VMDebug_threadCpuTimeNanos(JNIEnv*, jclass) {
194 return ThreadCpuNanoTime();
195 }
196
197 /*
198 * static void dumpHprofData(String fileName, FileDescriptor fd)
199 *
200 * Cause "hprof" data to be dumped. We can throw an IOException if an
201 * error occurs during file handling.
202 */
VMDebug_dumpHprofData(JNIEnv * env,jclass,jstring javaFilename,jobject javaFd)203 static void VMDebug_dumpHprofData(JNIEnv* env, jclass, jstring javaFilename, jobject javaFd) {
204 // Only one of these may be null.
205 if (javaFilename == nullptr && javaFd == nullptr) {
206 ScopedObjectAccess soa(env);
207 ThrowNullPointerException("fileName == null && fd == null");
208 return;
209 }
210
211 std::string filename;
212 if (javaFilename != nullptr) {
213 ScopedUtfChars chars(env, javaFilename);
214 if (env->ExceptionCheck()) {
215 return;
216 }
217 filename = chars.c_str();
218 } else {
219 filename = "[fd]";
220 }
221
222 int fd = -1;
223 if (javaFd != nullptr) {
224 fd = jniGetFDFromFileDescriptor(env, javaFd);
225 if (fd < 0) {
226 ScopedObjectAccess soa(env);
227 ThrowRuntimeException("Invalid file descriptor");
228 return;
229 }
230 }
231
232 hprof::DumpHeap(filename.c_str(), fd, false);
233 }
234
VMDebug_dumpHprofDataDdms(JNIEnv *,jclass)235 static void VMDebug_dumpHprofDataDdms(JNIEnv*, jclass) {
236 hprof::DumpHeap("[DDMS]", -1, true);
237 }
238
VMDebug_dumpReferenceTables(JNIEnv * env,jclass)239 static void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
240 ScopedObjectAccess soa(env);
241 LOG(INFO) << "--- reference table dump ---";
242
243 soa.Env()->DumpReferenceTables(LOG(INFO));
244 soa.Vm()->DumpReferenceTables(LOG(INFO));
245
246 LOG(INFO) << "---";
247 }
248
VMDebug_crash(JNIEnv *,jclass)249 static void VMDebug_crash(JNIEnv*, jclass) {
250 LOG(FATAL) << "Crashing runtime on request";
251 }
252
VMDebug_infopoint(JNIEnv *,jclass,jint id)253 static void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
254 LOG(INFO) << "VMDebug infopoint " << id << " hit";
255 }
256
VMDebug_countInstancesOfClass(JNIEnv * env,jclass,jclass javaClass,jboolean countAssignable)257 static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass,
258 jboolean countAssignable) {
259 ScopedObjectAccess soa(env);
260 gc::Heap* const heap = Runtime::Current()->GetHeap();
261 // Caller's responsibility to do GC if desired.
262 mirror::Class* c = soa.Decode<mirror::Class*>(javaClass);
263 if (c == nullptr) {
264 return 0;
265 }
266 std::vector<mirror::Class*> classes {c};
267 uint64_t count = 0;
268 heap->CountInstances(classes, countAssignable, &count);
269 return count;
270 }
271
VMDebug_countInstancesOfClasses(JNIEnv * env,jclass,jobjectArray javaClasses,jboolean countAssignable)272 static jlongArray VMDebug_countInstancesOfClasses(JNIEnv* env, jclass, jobjectArray javaClasses,
273 jboolean countAssignable) {
274 ScopedObjectAccess soa(env);
275 gc::Heap* const heap = Runtime::Current()->GetHeap();
276 // Caller's responsibility to do GC if desired.
277 auto* decoded_classes = soa.Decode<mirror::ObjectArray<mirror::Class>*>(javaClasses);
278 if (decoded_classes == nullptr) {
279 return nullptr;
280 }
281 std::vector<mirror::Class*> classes;
282 for (size_t i = 0, count = decoded_classes->GetLength(); i < count; ++i) {
283 classes.push_back(decoded_classes->Get(i));
284 }
285 std::vector<uint64_t> counts(classes.size(), 0u);
286 // Heap::CountInstances can handle null and will put 0 for these classes.
287 heap->CountInstances(classes, countAssignable, &counts[0]);
288 auto* long_counts = mirror::LongArray::Alloc(soa.Self(), counts.size());
289 if (long_counts == nullptr) {
290 soa.Self()->AssertPendingOOMException();
291 return nullptr;
292 }
293 for (size_t i = 0; i < counts.size(); ++i) {
294 long_counts->Set(i, counts[i]);
295 }
296 return soa.AddLocalReference<jlongArray>(long_counts);
297 }
298
299 // We export the VM internal per-heap-space size/alloc/free metrics
300 // for the zygote space, alloc space (application heap), and the large
301 // object space for dumpsys meminfo. The other memory region data such
302 // as PSS, private/shared dirty/shared data are available via
303 // /proc/<pid>/smaps.
VMDebug_getHeapSpaceStats(JNIEnv * env,jclass,jlongArray data)304 static void VMDebug_getHeapSpaceStats(JNIEnv* env, jclass, jlongArray data) {
305 jlong* arr = reinterpret_cast<jlong*>(env->GetPrimitiveArrayCritical(data, 0));
306 if (arr == nullptr || env->GetArrayLength(data) < 9) {
307 return;
308 }
309
310 size_t allocSize = 0;
311 size_t allocUsed = 0;
312 size_t zygoteSize = 0;
313 size_t zygoteUsed = 0;
314 size_t largeObjectsSize = 0;
315 size_t largeObjectsUsed = 0;
316 gc::Heap* heap = Runtime::Current()->GetHeap();
317 {
318 ScopedObjectAccess soa(env);
319 for (gc::space::ContinuousSpace* space : heap->GetContinuousSpaces()) {
320 if (space->IsImageSpace()) {
321 // Currently don't include the image space.
322 } else if (space->IsZygoteSpace()) {
323 gc::space::ZygoteSpace* zygote_space = space->AsZygoteSpace();
324 zygoteSize += zygote_space->Size();
325 zygoteUsed += zygote_space->GetBytesAllocated();
326 } else if (space->IsMallocSpace()) {
327 // This is a malloc space.
328 gc::space::MallocSpace* malloc_space = space->AsMallocSpace();
329 allocSize += malloc_space->GetFootprint();
330 allocUsed += malloc_space->GetBytesAllocated();
331 } else if (space->IsBumpPointerSpace()) {
332 gc::space::BumpPointerSpace* bump_pointer_space = space->AsBumpPointerSpace();
333 allocSize += bump_pointer_space->Size();
334 allocUsed += bump_pointer_space->GetBytesAllocated();
335 }
336 }
337 for (gc::space::DiscontinuousSpace* space : heap->GetDiscontinuousSpaces()) {
338 if (space->IsLargeObjectSpace()) {
339 largeObjectsSize += space->AsLargeObjectSpace()->GetBytesAllocated();
340 largeObjectsUsed += largeObjectsSize;
341 }
342 }
343 }
344 size_t allocFree = allocSize - allocUsed;
345 size_t zygoteFree = zygoteSize - zygoteUsed;
346 size_t largeObjectsFree = largeObjectsSize - largeObjectsUsed;
347
348 int j = 0;
349 arr[j++] = allocSize;
350 arr[j++] = allocUsed;
351 arr[j++] = allocFree;
352 arr[j++] = zygoteSize;
353 arr[j++] = zygoteUsed;
354 arr[j++] = zygoteFree;
355 arr[j++] = largeObjectsSize;
356 arr[j++] = largeObjectsUsed;
357 arr[j++] = largeObjectsFree;
358 env->ReleasePrimitiveArrayCritical(data, arr, 0);
359 }
360
361 // The runtime stat names for VMDebug.getRuntimeStat().
362 enum class VMDebugRuntimeStatId {
363 kArtGcGcCount = 0,
364 kArtGcGcTime,
365 kArtGcBytesAllocated,
366 kArtGcBytesFreed,
367 kArtGcBlockingGcCount,
368 kArtGcBlockingGcTime,
369 kArtGcGcCountRateHistogram,
370 kArtGcBlockingGcCountRateHistogram,
371 kNumRuntimeStats,
372 };
373
VMDebug_getRuntimeStatInternal(JNIEnv * env,jclass,jint statId)374 static jobject VMDebug_getRuntimeStatInternal(JNIEnv* env, jclass, jint statId) {
375 gc::Heap* heap = Runtime::Current()->GetHeap();
376 switch (static_cast<VMDebugRuntimeStatId>(statId)) {
377 case VMDebugRuntimeStatId::kArtGcGcCount: {
378 std::string output = std::to_string(heap->GetGcCount());
379 return env->NewStringUTF(output.c_str());
380 }
381 case VMDebugRuntimeStatId::kArtGcGcTime: {
382 std::string output = std::to_string(NsToMs(heap->GetGcTime()));
383 return env->NewStringUTF(output.c_str());
384 }
385 case VMDebugRuntimeStatId::kArtGcBytesAllocated: {
386 std::string output = std::to_string(heap->GetBytesAllocatedEver());
387 return env->NewStringUTF(output.c_str());
388 }
389 case VMDebugRuntimeStatId::kArtGcBytesFreed: {
390 std::string output = std::to_string(heap->GetBytesFreedEver());
391 return env->NewStringUTF(output.c_str());
392 }
393 case VMDebugRuntimeStatId::kArtGcBlockingGcCount: {
394 std::string output = std::to_string(heap->GetBlockingGcCount());
395 return env->NewStringUTF(output.c_str());
396 }
397 case VMDebugRuntimeStatId::kArtGcBlockingGcTime: {
398 std::string output = std::to_string(NsToMs(heap->GetBlockingGcTime()));
399 return env->NewStringUTF(output.c_str());
400 }
401 case VMDebugRuntimeStatId::kArtGcGcCountRateHistogram: {
402 std::ostringstream output;
403 heap->DumpGcCountRateHistogram(output);
404 return env->NewStringUTF(output.str().c_str());
405 }
406 case VMDebugRuntimeStatId::kArtGcBlockingGcCountRateHistogram: {
407 std::ostringstream output;
408 heap->DumpBlockingGcCountRateHistogram(output);
409 return env->NewStringUTF(output.str().c_str());
410 }
411 default:
412 return nullptr;
413 }
414 }
415
SetRuntimeStatValue(JNIEnv * env,jobjectArray result,VMDebugRuntimeStatId id,std::string value)416 static bool SetRuntimeStatValue(JNIEnv* env, jobjectArray result, VMDebugRuntimeStatId id,
417 std::string value) {
418 ScopedLocalRef<jstring> jvalue(env, env->NewStringUTF(value.c_str()));
419 if (jvalue.get() == nullptr) {
420 return false;
421 }
422 env->SetObjectArrayElement(result, static_cast<jint>(id), jvalue.get());
423 return true;
424 }
425
VMDebug_getRuntimeStatsInternal(JNIEnv * env,jclass)426 static jobjectArray VMDebug_getRuntimeStatsInternal(JNIEnv* env, jclass) {
427 jobjectArray result = env->NewObjectArray(
428 static_cast<jint>(VMDebugRuntimeStatId::kNumRuntimeStats),
429 WellKnownClasses::java_lang_String,
430 nullptr);
431 if (result == nullptr) {
432 return nullptr;
433 }
434 gc::Heap* heap = Runtime::Current()->GetHeap();
435 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcGcCount,
436 std::to_string(heap->GetGcCount()))) {
437 return nullptr;
438 }
439 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcGcTime,
440 std::to_string(NsToMs(heap->GetGcTime())))) {
441 return nullptr;
442 }
443 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcBytesAllocated,
444 std::to_string(heap->GetBytesAllocatedEver()))) {
445 return nullptr;
446 }
447 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcBytesFreed,
448 std::to_string(heap->GetBytesFreedEver()))) {
449 return nullptr;
450 }
451 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcBlockingGcCount,
452 std::to_string(heap->GetBlockingGcCount()))) {
453 return nullptr;
454 }
455 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcBlockingGcTime,
456 std::to_string(NsToMs(heap->GetBlockingGcTime())))) {
457 return nullptr;
458 }
459 {
460 std::ostringstream output;
461 heap->DumpGcCountRateHistogram(output);
462 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcGcCountRateHistogram,
463 output.str())) {
464 return nullptr;
465 }
466 }
467 {
468 std::ostringstream output;
469 heap->DumpBlockingGcCountRateHistogram(output);
470 if (!SetRuntimeStatValue(env, result, VMDebugRuntimeStatId::kArtGcBlockingGcCountRateHistogram,
471 output.str())) {
472 return nullptr;
473 }
474 }
475 return result;
476 }
477
478 static JNINativeMethod gMethods[] = {
479 NATIVE_METHOD(VMDebug, countInstancesOfClass, "(Ljava/lang/Class;Z)J"),
480 NATIVE_METHOD(VMDebug, countInstancesOfClasses, "([Ljava/lang/Class;Z)[J"),
481 NATIVE_METHOD(VMDebug, crash, "()V"),
482 NATIVE_METHOD(VMDebug, dumpHprofData, "(Ljava/lang/String;Ljava/io/FileDescriptor;)V"),
483 NATIVE_METHOD(VMDebug, dumpHprofDataDdms, "()V"),
484 NATIVE_METHOD(VMDebug, dumpReferenceTables, "()V"),
485 NATIVE_METHOD(VMDebug, getAllocCount, "(I)I"),
486 NATIVE_METHOD(VMDebug, getHeapSpaceStats, "([J)V"),
487 NATIVE_METHOD(VMDebug, getInstructionCount, "([I)V"),
488 NATIVE_METHOD(VMDebug, getLoadedClassCount, "!()I"),
489 NATIVE_METHOD(VMDebug, getVmFeatureList, "()[Ljava/lang/String;"),
490 NATIVE_METHOD(VMDebug, infopoint, "(I)V"),
491 NATIVE_METHOD(VMDebug, isDebuggerConnected, "!()Z"),
492 NATIVE_METHOD(VMDebug, isDebuggingEnabled, "!()Z"),
493 NATIVE_METHOD(VMDebug, getMethodTracingMode, "()I"),
494 NATIVE_METHOD(VMDebug, lastDebuggerActivity, "!()J"),
495 NATIVE_METHOD(VMDebug, printLoadedClasses, "!(I)V"),
496 NATIVE_METHOD(VMDebug, resetAllocCount, "(I)V"),
497 NATIVE_METHOD(VMDebug, resetInstructionCount, "()V"),
498 NATIVE_METHOD(VMDebug, startAllocCounting, "()V"),
499 NATIVE_METHOD(VMDebug, startEmulatorTracing, "()V"),
500 NATIVE_METHOD(VMDebug, startInstructionCounting, "()V"),
501 NATIVE_METHOD(VMDebug, startMethodTracingDdmsImpl, "(IIZI)V"),
502 NATIVE_METHOD(VMDebug, startMethodTracingFd, "(Ljava/lang/String;Ljava/io/FileDescriptor;IIZI)V"),
503 NATIVE_METHOD(VMDebug, startMethodTracingFilename, "(Ljava/lang/String;IIZI)V"),
504 NATIVE_METHOD(VMDebug, stopAllocCounting, "()V"),
505 NATIVE_METHOD(VMDebug, stopEmulatorTracing, "()V"),
506 NATIVE_METHOD(VMDebug, stopInstructionCounting, "()V"),
507 NATIVE_METHOD(VMDebug, stopMethodTracing, "()V"),
508 NATIVE_METHOD(VMDebug, threadCpuTimeNanos, "!()J"),
509 NATIVE_METHOD(VMDebug, getRuntimeStatInternal, "(I)Ljava/lang/String;"),
510 NATIVE_METHOD(VMDebug, getRuntimeStatsInternal, "()[Ljava/lang/String;")
511 };
512
register_dalvik_system_VMDebug(JNIEnv * env)513 void register_dalvik_system_VMDebug(JNIEnv* env) {
514 REGISTER_NATIVE_METHODS("dalvik/system/VMDebug");
515 }
516
517 } // namespace art
518