ART: Remove IRT cruft
Remove dead code for initial vs maximum table size.
Bug: 32125344
Test: m test-art-host
Change-Id: Ie5806da7f5f3238483da918deca5982f01764466
diff --git a/runtime/indirect_reference_table.cc b/runtime/indirect_reference_table.cc
index 6109ec6..130c10d 100644
--- a/runtime/indirect_reference_table.cc
+++ b/runtime/indirect_reference_table.cc
@@ -58,17 +58,15 @@
}
}
-IndirectReferenceTable::IndirectReferenceTable(size_t initialCount,
- size_t maxCount, IndirectRefKind desiredKind,
+IndirectReferenceTable::IndirectReferenceTable(size_t max_count,
+ IndirectRefKind desired_kind,
bool abort_on_error)
- : kind_(desiredKind),
- max_entries_(maxCount) {
- CHECK_GT(initialCount, 0U);
- CHECK_LE(initialCount, maxCount);
- CHECK_NE(desiredKind, kHandleScopeOrInvalid);
+ : kind_(desired_kind),
+ max_entries_(max_count) {
+ CHECK_NE(desired_kind, kHandleScopeOrInvalid);
std::string error_str;
- const size_t table_bytes = maxCount * sizeof(IrtEntry);
+ const size_t table_bytes = max_count * sizeof(IrtEntry);
table_mem_map_.reset(MemMap::MapAnonymous("indirect ref table", nullptr, table_bytes,
PROT_READ | PROT_WRITE, false, false, &error_str));
if (abort_on_error) {
diff --git a/runtime/indirect_reference_table.h b/runtime/indirect_reference_table.h
index 64de7a8..1762b10 100644
--- a/runtime/indirect_reference_table.h
+++ b/runtime/indirect_reference_table.h
@@ -259,8 +259,7 @@
public:
// WARNING: When using with abort_on_error = false, the object may be in a partially
// initialized state. Use IsValid() to check.
- IndirectReferenceTable(size_t initialCount, size_t maxCount, IndirectRefKind kind,
- bool abort_on_error = true);
+ IndirectReferenceTable(size_t max_count, IndirectRefKind kind, bool abort_on_error = true);
~IndirectReferenceTable();
diff --git a/runtime/indirect_reference_table_test.cc b/runtime/indirect_reference_table_test.cc
index 1699110..7b28f0b 100644
--- a/runtime/indirect_reference_table_test.cc
+++ b/runtime/indirect_reference_table_test.cc
@@ -48,9 +48,8 @@
ScopedLogSeverity sls(LogSeverity::FATAL);
ScopedObjectAccess soa(Thread::Current());
- static const size_t kTableInitial = 10;
static const size_t kTableMax = 20;
- IndirectReferenceTable irt(kTableInitial, kTableMax, kGlobal);
+ IndirectReferenceTable irt(kTableMax, kGlobal);
mirror::Class* c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
StackHandleScope<4> hs(soa.Self());
@@ -230,6 +229,7 @@
// Test table resizing.
// These ones fit...
+ static const size_t kTableInitial = kTableMax / 2;
IndirectRef manyRefs[kTableInitial];
for (size_t i = 0; i < kTableInitial; i++) {
manyRefs[i] = irt.Add(cookie, obj0.Get());
diff --git a/runtime/java_vm_ext.cc b/runtime/java_vm_ext.cc
index f2bda05..99edb7c 100644
--- a/runtime/java_vm_ext.cc
+++ b/runtime/java_vm_ext.cc
@@ -42,11 +42,9 @@
namespace art {
-static size_t gGlobalsInitial = 512; // Arbitrary.
-static size_t gGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
+static constexpr size_t kGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
-static const size_t kWeakGlobalsInitial = 16; // Arbitrary.
-static const size_t kWeakGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
+static constexpr size_t kWeakGlobalsMax = 51200; // Arbitrary sanity check. (Must fit in 16 bits.)
bool JavaVMExt::IsBadJniVersion(int version) {
// We don't support JNI_VERSION_1_1. These are the only other valid versions.
@@ -422,10 +420,10 @@
tracing_enabled_(runtime_options.Exists(RuntimeArgumentMap::JniTrace)
|| VLOG_IS_ON(third_party_jni)),
trace_(runtime_options.GetOrDefault(RuntimeArgumentMap::JniTrace)),
- globals_(gGlobalsInitial, gGlobalsMax, kGlobal),
+ globals_(kGlobalsMax, kGlobal),
libraries_(new Libraries),
unchecked_functions_(&gJniInvokeInterface),
- weak_globals_(kWeakGlobalsInitial, kWeakGlobalsMax, kWeakGlobal),
+ weak_globals_(kWeakGlobalsMax, kWeakGlobal),
allow_accessing_weak_globals_(true),
weak_globals_add_condition_("weak globals add condition",
(CHECK(Locks::jni_weak_globals_lock_ != nullptr),
diff --git a/runtime/jni_env_ext.cc b/runtime/jni_env_ext.cc
index 3c749d0..39f4d97 100644
--- a/runtime/jni_env_ext.cc
+++ b/runtime/jni_env_ext.cc
@@ -33,8 +33,6 @@
static constexpr size_t kMonitorsInitial = 32; // Arbitrary.
static constexpr size_t kMonitorsMax = 4096; // Arbitrary sanity check.
-static constexpr size_t kLocalsInitial = 64; // Arbitrary.
-
// Checking "locals" requires the mutator lock, but at creation time we're really only interested
// in validity, which isn't changing. To avoid grabbing the mutator lock, factored out and tagged
// with NO_THREAD_SAFETY_ANALYSIS.
@@ -71,7 +69,7 @@
: self(self_in),
vm(vm_in),
local_ref_cookie(IRT_FIRST_SEGMENT),
- locals(kLocalsInitial, kLocalsMax, kLocal, false),
+ locals(kLocalsInitial, kLocal, false),
check_jni(false),
runtime_deleted(false),
critical(0),
diff --git a/runtime/jni_env_ext.h b/runtime/jni_env_ext.h
index 121f848..549f8c5 100644
--- a/runtime/jni_env_ext.h
+++ b/runtime/jni_env_ext.h
@@ -29,9 +29,9 @@
class JavaVMExt;
-// Maximum number of local references in the indirect reference table. The value is arbitrary but
+// Number of local references in the indirect reference table. The value is arbitrary but
// low enough that it forces sanity checks.
-static constexpr size_t kLocalsMax = 512;
+static constexpr size_t kLocalsInitial = 512;
struct JNIEnvExt : public JNIEnv {
static JNIEnvExt* Create(Thread* self, JavaVMExt* vm);
diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc
index 8eebe56..9b18fa1 100644
--- a/runtime/jni_internal.cc
+++ b/runtime/jni_internal.cc
@@ -2394,13 +2394,13 @@
const char* caller)
REQUIRES_SHARED(Locks::mutator_lock_) {
// TODO: we should try to expand the table if necessary.
- if (desired_capacity < 0 || desired_capacity > static_cast<jint>(kLocalsMax)) {
+ if (desired_capacity < 0 || desired_capacity > static_cast<jint>(kLocalsInitial)) {
LOG(ERROR) << "Invalid capacity given to " << caller << ": " << desired_capacity;
return JNI_ERR;
}
// TODO: this isn't quite right, since "capacity" includes holes.
const size_t capacity = soa.Env()->locals.Capacity();
- bool okay = (static_cast<jint>(kLocalsMax - capacity) >= desired_capacity);
+ bool okay = (static_cast<jint>(kLocalsInitial - capacity) >= desired_capacity);
if (!okay) {
soa.Self()->ThrowOutOfMemoryError(caller);
}
diff --git a/runtime/jni_internal_test.cc b/runtime/jni_internal_test.cc
index fbd670c..9622a8e 100644
--- a/runtime/jni_internal_test.cc
+++ b/runtime/jni_internal_test.cc
@@ -865,6 +865,11 @@
GetStaticMethodIdBadArgumentTest(true);
}
+static size_t GetLocalsCapacity(JNIEnv* env) {
+ ScopedObjectAccess soa(Thread::Current());
+ return reinterpret_cast<JNIEnvExt*>(env)->locals.Capacity();
+}
+
TEST_F(JniInternalTest, FromReflectedField_ToReflectedField) {
jclass jlrField = env_->FindClass("java/lang/reflect/Field");
jclass c = env_->FindClass("java/lang/String");
@@ -873,11 +878,15 @@
ASSERT_NE(fid, nullptr);
// Turn the fid into a java.lang.reflect.Field...
jobject field = env_->ToReflectedField(c, fid, JNI_FALSE);
- for (size_t i = 0; i <= kLocalsMax; ++i) {
+ size_t capacity_before = GetLocalsCapacity(env_);
+ for (size_t i = 0; i <= 10; ++i) {
// Regression test for b/18396311, ToReflectedField leaking local refs causing a local
// reference table overflows with 512 references to ArtField
env_->DeleteLocalRef(env_->ToReflectedField(c, fid, JNI_FALSE));
}
+ size_t capacity_after = GetLocalsCapacity(env_);
+ ASSERT_EQ(capacity_before, capacity_after);
+
ASSERT_NE(c, nullptr);
ASSERT_TRUE(env_->IsInstanceOf(field, jlrField));
// ...and back again.
@@ -911,11 +920,14 @@
ASSERT_NE(mid, nullptr);
// Turn the mid into a java.lang.reflect.Constructor...
jobject method = env_->ToReflectedMethod(c, mid, JNI_FALSE);
- for (size_t i = 0; i <= kLocalsMax; ++i) {
+ size_t capacity_before = GetLocalsCapacity(env_);
+ for (size_t i = 0; i <= 10; ++i) {
// Regression test for b/18396311, ToReflectedMethod leaking local refs causing a local
// reference table overflows with 512 references to ArtMethod
env_->DeleteLocalRef(env_->ToReflectedMethod(c, mid, JNI_FALSE));
}
+ size_t capacity_after = GetLocalsCapacity(env_);
+ ASSERT_EQ(capacity_before, capacity_after);
ASSERT_NE(method, nullptr);
ASSERT_TRUE(env_->IsInstanceOf(method, jlrConstructor));
// ...and back again.
@@ -2295,7 +2307,7 @@
// The segment_state_ field is private, and we want to avoid friend declaration. So we'll check
// by modifying memory.
// The parameters don't really matter here.
- IndirectReferenceTable irt(5, 5, IndirectRefKind::kGlobal, true);
+ IndirectReferenceTable irt(5, IndirectRefKind::kGlobal, true);
uint32_t old_state = irt.GetSegmentState();
// Write some new state directly. We invert parts of old_state to ensure a new value.