rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/art/test/906-iterate-heap/iterate_heap.cc

439 lines
15 KiB
C++
Raw Blame History

/*
* 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.
*/
#include <inttypes.h>
#include <pthread.h>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <vector>
#include "android-base/logging.h"
#include "android-base/stringprintf.h"
#include "jni.h"
#include "jvmti.h"
#include "scoped_primitive_array.h"
// Test infrastructure
#include "jvmti_helper.h"
#include "test_env.h"
#include "ti_macros.h"
#include "ti_utf.h"
namespace art {
namespace Test906IterateHeap {
class IterationConfig {
public:
IterationConfig() {}
virtual ~IterationConfig() {}
virtual jint Handle(jlong class_tag, jlong size, jlong* tag_ptr, jint length) = 0;
};
static jint JNICALL HeapIterationCallback(jlong class_tag,
jlong size,
jlong* tag_ptr,
jint length,
void* user_data) {
IterationConfig* config = reinterpret_cast<IterationConfig*>(user_data);
return config->Handle(class_tag, size, tag_ptr, length);
}
static bool Run(JNIEnv* env, jint heap_filter, jclass klass_filter, IterationConfig* config) {
jvmtiHeapCallbacks callbacks;
memset(&callbacks, 0, sizeof(jvmtiHeapCallbacks));
callbacks.heap_iteration_callback = HeapIterationCallback;
jvmtiError ret = jvmti_env->IterateThroughHeap(heap_filter,
klass_filter,
&callbacks,
config);
if (JvmtiErrorToException(env, jvmti_env, ret)) {
return false;
}
return true;
}
extern "C" JNIEXPORT jint JNICALL Java_art_Test906_iterateThroughHeapCount(
JNIEnv* env,
jclass klass ATTRIBUTE_UNUSED,
jint heap_filter,
jclass klass_filter,
jint stop_after) {
class CountIterationConfig : public IterationConfig {
public:
CountIterationConfig(jint _counter, jint _stop_after)
: counter(_counter),
stop_after(_stop_after) {
}
jint Handle(jlong class_tag ATTRIBUTE_UNUSED,
jlong size ATTRIBUTE_UNUSED,
jlong* tag_ptr ATTRIBUTE_UNUSED,
jint length ATTRIBUTE_UNUSED) override {
counter++;
if (counter == stop_after) {
return JVMTI_VISIT_ABORT;
}
return 0;
}
jint counter;
const jint stop_after;
};
CountIterationConfig config(0, stop_after);
Run(env, heap_filter, klass_filter, &config);
if (config.counter > config.stop_after) {
printf("Error: more objects visited than signaled.");
}
return config.counter;
}
extern "C" JNIEXPORT jint JNICALL Java_art_Test906_iterateThroughHeapData(
JNIEnv* env,
jclass klass ATTRIBUTE_UNUSED,
jint heap_filter,
jclass klass_filter,
jlongArray class_tags,
jlongArray sizes,
jlongArray tags,
jintArray lengths) {
class DataIterationConfig : public IterationConfig {
public:
jint Handle(jlong class_tag, jlong size, jlong* tag_ptr, jint length) override {
class_tags_.push_back(class_tag);
sizes_.push_back(size);
tags_.push_back(*tag_ptr);
lengths_.push_back(length);
return 0; // Continue.
}
std::vector<jlong> class_tags_;
std::vector<jlong> sizes_;
std::vector<jlong> tags_;
std::vector<jint> lengths_;
};
DataIterationConfig config;
if (!Run(env, heap_filter, klass_filter, &config)) {
return -1;
}
ScopedLongArrayRW s_class_tags(env, class_tags);
ScopedLongArrayRW s_sizes(env, sizes);
ScopedLongArrayRW s_tags(env, tags);
ScopedIntArrayRW s_lengths(env, lengths);
for (size_t i = 0; i != config.class_tags_.size(); ++i) {
s_class_tags[i] = config.class_tags_[i];
s_sizes[i] = config.sizes_[i];
s_tags[i] = config.tags_[i];
s_lengths[i] = config.lengths_[i];
}
return static_cast<jint>(config.class_tags_.size());
}
extern "C" JNIEXPORT void JNICALL Java_art_Test906_iterateThroughHeapAdd(
JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jint heap_filter, jclass klass_filter) {
class AddIterationConfig : public IterationConfig {
public:
AddIterationConfig() {}
jint Handle(jlong class_tag ATTRIBUTE_UNUSED,
jlong size ATTRIBUTE_UNUSED,
jlong* tag_ptr,
jint length ATTRIBUTE_UNUSED) override {
jlong current_tag = *tag_ptr;
if (current_tag != 0) {
*tag_ptr = current_tag + 10;
}
return 0;
}
};
AddIterationConfig config;
Run(env, heap_filter, klass_filter, &config);
}
extern "C" JNIEXPORT jstring JNICALL Java_art_Test906_iterateThroughHeapString(
JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jlong tag) {
struct FindStringCallbacks {
explicit FindStringCallbacks(jlong t) : tag_to_find(t) {}
static jint JNICALL HeapIterationCallback(jlong class_tag ATTRIBUTE_UNUSED,
jlong size ATTRIBUTE_UNUSED,
jlong* tag_ptr ATTRIBUTE_UNUSED,
jint length ATTRIBUTE_UNUSED,
void* user_data ATTRIBUTE_UNUSED) {
return 0;
}
static jint JNICALL StringValueCallback(jlong class_tag,
jlong size,
jlong* tag_ptr,
const jchar* value,
jint value_length,
void* user_data) {
FindStringCallbacks* p = reinterpret_cast<FindStringCallbacks*>(user_data);
if (*tag_ptr == p->tag_to_find) {
size_t utf_byte_count = ti::CountUtf8Bytes(value, value_length);
std::unique_ptr<char[]> mod_utf(new char[utf_byte_count + 1]);
memset(mod_utf.get(), 0, utf_byte_count + 1);
ti::ConvertUtf16ToModifiedUtf8(mod_utf.get(), utf_byte_count, value, value_length);
if (!p->data.empty()) {
p->data += "\n";
}
p->data += android::base::StringPrintf("%" PRId64 "@%" PRId64 " (%" PRId64 ", '%s')",
*tag_ptr,
class_tag,
size,
mod_utf.get());
// Update the tag to test whether that works.
*tag_ptr = *tag_ptr + 1;
}
return 0;
}
std::string data;
const jlong tag_to_find;
};
jvmtiHeapCallbacks callbacks;
memset(&callbacks, 0, sizeof(jvmtiHeapCallbacks));
callbacks.heap_iteration_callback = FindStringCallbacks::HeapIterationCallback;
callbacks.string_primitive_value_callback = FindStringCallbacks::StringValueCallback;
FindStringCallbacks fsc(tag);
jvmtiError ret = jvmti_env->IterateThroughHeap(0, nullptr, &callbacks, &fsc);
if (JvmtiErrorToException(env, jvmti_env, ret)) {
return nullptr;
}
return env->NewStringUTF(fsc.data.c_str());
}
extern "C" JNIEXPORT jstring JNICALL Java_art_Test906_iterateThroughHeapPrimitiveArray(
JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jlong tag) {
struct FindArrayCallbacks {
explicit FindArrayCallbacks(jlong t) : tag_to_find(t) {}
static jint JNICALL HeapIterationCallback(jlong class_tag ATTRIBUTE_UNUSED,
jlong size ATTRIBUTE_UNUSED,
jlong* tag_ptr ATTRIBUTE_UNUSED,
jint length ATTRIBUTE_UNUSED,
void* user_data ATTRIBUTE_UNUSED) {
return 0;
}
static jint JNICALL ArrayValueCallback(jlong class_tag,
jlong size,
jlong* tag_ptr,
jint element_count,
jvmtiPrimitiveType element_type,
const void* elements,
void* user_data) {
FindArrayCallbacks* p = reinterpret_cast<FindArrayCallbacks*>(user_data);
if (*tag_ptr == p->tag_to_find) {
std::ostringstream oss;
oss << *tag_ptr
<< '@'
<< class_tag
<< " ("
<< size
<< ", "
<< element_count
<< "x"
<< static_cast<char>(element_type)
<< " '";
size_t element_size;
switch (element_type) {
case JVMTI_PRIMITIVE_TYPE_BOOLEAN:
case JVMTI_PRIMITIVE_TYPE_BYTE:
element_size = 1;
break;
case JVMTI_PRIMITIVE_TYPE_CHAR:
case JVMTI_PRIMITIVE_TYPE_SHORT:
element_size = 2;
break;
case JVMTI_PRIMITIVE_TYPE_INT:
case JVMTI_PRIMITIVE_TYPE_FLOAT:
element_size = 4;
break;
case JVMTI_PRIMITIVE_TYPE_LONG:
case JVMTI_PRIMITIVE_TYPE_DOUBLE:
element_size = 8;
break;
default:
LOG(FATAL) << "Unknown type " << static_cast<size_t>(element_type);
UNREACHABLE();
}
const uint8_t* data = reinterpret_cast<const uint8_t*>(elements);
for (size_t i = 0; i != element_size * element_count; ++i) {
oss << android::base::StringPrintf("%02x", data[i]);
}
oss << "')";
if (!p->data.empty()) {
p->data += "\n";
}
p->data += oss.str();
// Update the tag to test whether that works.
*tag_ptr = *tag_ptr + 1;
}
return 0;
}
std::string data;
const jlong tag_to_find;
};
jvmtiHeapCallbacks callbacks;
memset(&callbacks, 0, sizeof(jvmtiHeapCallbacks));
callbacks.heap_iteration_callback = FindArrayCallbacks::HeapIterationCallback;
callbacks.array_primitive_value_callback = FindArrayCallbacks::ArrayValueCallback;
FindArrayCallbacks fac(tag);
jvmtiError ret = jvmti_env->IterateThroughHeap(0, nullptr, &callbacks, &fac);
if (JvmtiErrorToException(env, jvmti_env, ret)) {
return nullptr;
}
return env->NewStringUTF(fac.data.c_str());
}
static constexpr const char* GetPrimitiveTypeName(jvmtiPrimitiveType type) {
switch (type) {
case JVMTI_PRIMITIVE_TYPE_BOOLEAN:
return "boolean";
case JVMTI_PRIMITIVE_TYPE_BYTE:
return "byte";
case JVMTI_PRIMITIVE_TYPE_CHAR:
return "char";
case JVMTI_PRIMITIVE_TYPE_SHORT:
return "short";
case JVMTI_PRIMITIVE_TYPE_INT:
return "int";
case JVMTI_PRIMITIVE_TYPE_FLOAT:
return "float";
case JVMTI_PRIMITIVE_TYPE_LONG:
return "long";
case JVMTI_PRIMITIVE_TYPE_DOUBLE:
return "double";
}
LOG(FATAL) << "Unknown type " << static_cast<size_t>(type);
UNREACHABLE();
}
extern "C" JNIEXPORT jstring JNICALL Java_art_Test906_iterateThroughHeapPrimitiveFields(
JNIEnv* env, jclass klass ATTRIBUTE_UNUSED, jlong tag) {
struct FindFieldCallbacks {
explicit FindFieldCallbacks(jlong t) : tag_to_find(t) {}
static jint JNICALL HeapIterationCallback(jlong class_tag ATTRIBUTE_UNUSED,
jlong size ATTRIBUTE_UNUSED,
jlong* tag_ptr ATTRIBUTE_UNUSED,
jint length ATTRIBUTE_UNUSED,
void* user_data ATTRIBUTE_UNUSED) {
return 0;
}
static jint JNICALL PrimitiveFieldValueCallback(jvmtiHeapReferenceKind kind,
const jvmtiHeapReferenceInfo* info,
jlong class_tag,
jlong* tag_ptr,
jvalue value,
jvmtiPrimitiveType value_type,
void* user_data) {
FindFieldCallbacks* p = reinterpret_cast<FindFieldCallbacks*>(user_data);
if (*tag_ptr >= p->tag_to_find) {
std::ostringstream oss;
oss << *tag_ptr
<< '@'
<< class_tag
<< " ("
<< (kind == JVMTI_HEAP_REFERENCE_FIELD ? "instance, " : "static, ")
<< GetPrimitiveTypeName(value_type)
<< ", index="
<< info->field.index
<< ") ";
// Be lazy, always print eight bytes.
static_assert(sizeof(jvalue) == sizeof(uint64_t), "Unexpected jvalue size");
uint64_t val;
memcpy(&val, &value, sizeof(uint64_t)); // To avoid undefined behavior.
oss << android::base::StringPrintf("%016" PRIx64, val);
if (!p->data.empty()) {
p->data += "\n";
}
p->data += oss.str();
*tag_ptr = *tag_ptr + 1;
}
return 0;
}
std::string data;
const jlong tag_to_find;
};
jvmtiHeapCallbacks callbacks;
memset(&callbacks, 0, sizeof(jvmtiHeapCallbacks));
callbacks.heap_iteration_callback = FindFieldCallbacks::HeapIterationCallback;
callbacks.primitive_field_callback = FindFieldCallbacks::PrimitiveFieldValueCallback;
FindFieldCallbacks ffc(tag);
jvmtiError ret = jvmti_env->IterateThroughHeap(0, nullptr, &callbacks, &ffc);
if (JvmtiErrorToException(env, jvmti_env, ret)) {
return nullptr;
}
return env->NewStringUTF(ffc.data.c_str());
}
extern "C" JNIEXPORT jboolean JNICALL Java_art_Test906_checkInitialized(
JNIEnv* env, jclass, jclass c) {
jint status;
jvmtiError error = jvmti_env->GetClassStatus(c, &status);
if (JvmtiErrorToException(env, jvmti_env, error)) {
return false;
}
return (status & JVMTI_CLASS_STATUS_INITIALIZED) != 0;
}
extern "C" JNIEXPORT jint JNICALL Java_art_Test906_iterateOverInstancesCount(
JNIEnv* env, jclass, jclass target) {
jint cnt = 0;
auto count_func = [](jlong, jlong, jlong*, void* user_data) -> jvmtiIterationControl {
*reinterpret_cast<jint*>(user_data) += 1;
return JVMTI_ITERATION_CONTINUE;
};
JvmtiErrorToException(env,
jvmti_env,
jvmti_env->IterateOverInstancesOfClass(target,
JVMTI_HEAP_OBJECT_EITHER,
count_func,
&cnt));
return cnt;
}
} // namespace Test906IterateHeap
} // namespace art
Reference in New Issue View Git Blame Copy Permalink