Compile time performance improvements focusing on interpret-only.
Reduce virtual method dispatch in the method verifier and make more code
inline-able.
Add a StringPiece with const char* equality operator to avoid redundant
StringPieces and strlens.
Remove back link from register line to verifier and pass as argument to reduce
size of RegisterLine.
Remove instruction length from instruction flags and compute from the
instruction, again to reduce size.
Add suspend checks to resolve and verify to allow for more easy monitor
inflation and reduce contention on Locks::thread_list_suspend_thread_lock_.
Change ThrowEarlierClassFailure to throw pre-allocated exception.
Avoid calls to Thread::Current() by passing self.
Template specialize IsValidClassName.
Make ANR reporting with SIGQUIT run using checkpoints rather than suspending
all threads. This makes the stack/lock analysis less lock error prone.
Extra Barrier assertions and condition variable time out is now returned as a
boolean both from Barrier and ConditionVariable::Wait.
2 threaded host x86-64 interpret-only numbers from 341 samples:
Before change: Avg 176.137ms 99% CI 3.468ms to 1060.770ms
After change: Avg 139.163% 99% CI 3.027ms to 838.257ms
Reduction in average compile time after change is 20.9%.
Slow-down without change is 26.5%.
Bug: 17471626 - Fix bug where RegTypeCache::JavaLangObject/String/Class/Throwable
could return unresolved type when class loading is disabled.
Bug: 17398101
Change-Id: Id59ce3cc520701c6ecf612f7152498107bc40684
diff --git a/runtime/verifier/reg_type_cache.cc b/runtime/verifier/reg_type_cache.cc
index 92a005b..121fccb 100644
--- a/runtime/verifier/reg_type_cache.cc
+++ b/runtime/verifier/reg_type_cache.cc
@@ -21,15 +21,16 @@
#include "dex_file-inl.h"
#include "mirror/class-inl.h"
#include "mirror/object-inl.h"
+#include "reg_type-inl.h"
namespace art {
namespace verifier {
bool RegTypeCache::primitive_initialized_ = false;
uint16_t RegTypeCache::primitive_count_ = 0;
-PreciseConstType* RegTypeCache::small_precise_constants_[kMaxSmallConstant - kMinSmallConstant + 1];
+const PreciseConstType* RegTypeCache::small_precise_constants_[kMaxSmallConstant - kMinSmallConstant + 1];
-static bool MatchingPrecisionForClass(RegType* entry, bool precise)
+static bool MatchingPrecisionForClass(const RegType* entry, bool precise)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (entry->IsPreciseReference() == precise) {
// We were or weren't looking for a precise reference and we found what we need.
@@ -98,7 +99,7 @@
};
const RegType& RegTypeCache::RegTypeFromPrimitiveType(Primitive::Type prim_type) const {
- CHECK(RegTypeCache::primitive_initialized_);
+ DCHECK(RegTypeCache::primitive_initialized_);
switch (prim_type) {
case Primitive::kPrimBoolean:
return *BooleanType::GetInstance();
@@ -123,7 +124,7 @@
}
bool RegTypeCache::MatchDescriptor(size_t idx, const StringPiece& descriptor, bool precise) {
- RegType* entry = entries_[idx];
+ const RegType* entry = entries_[idx];
if (descriptor != entry->descriptor_) {
return false;
}
@@ -143,11 +144,11 @@
Thread* self = Thread::Current();
StackHandleScope<1> hs(self);
Handle<mirror::ClassLoader> class_loader(hs.NewHandle(loader));
- mirror::Class* klass = NULL;
+ mirror::Class* klass = nullptr;
if (can_load_classes_) {
klass = class_linker->FindClass(self, descriptor, class_loader);
} else {
- klass = class_linker->LookupClass(descriptor, loader);
+ klass = class_linker->LookupClass(self, descriptor, loader);
if (klass != nullptr && !klass->IsLoaded()) {
// We found the class but without it being loaded its not safe for use.
klass = nullptr;
@@ -169,7 +170,7 @@
// Class not found in the cache, will create a new type for that.
// Try resolving class.
mirror::Class* klass = ResolveClass(descriptor, loader);
- if (klass != NULL) {
+ if (klass != nullptr) {
// Class resolved, first look for the class in the list of entries
// Class was not found, must create new type.
// To pass the verification, the type should be imprecise,
@@ -219,7 +220,7 @@
} else {
// Look for the reference in the list of entries to have.
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->klass_.Read() == klass && MatchingPrecisionForClass(cur_entry, precise)) {
return *cur_entry;
}
@@ -237,8 +238,8 @@
}
RegTypeCache::RegTypeCache(bool can_load_classes) : can_load_classes_(can_load_classes) {
- if (kIsDebugBuild && can_load_classes) {
- Thread::Current()->AssertThreadSuspensionIsAllowable();
+ if (kIsDebugBuild) {
+ Thread::Current()->AssertThreadSuspensionIsAllowable(gAborting == 0);
}
entries_.reserve(64);
FillPrimitiveAndSmallConstantTypes();
@@ -251,7 +252,7 @@
// All entries are from the global pool, nothing to delete.
return;
}
- std::vector<RegType*>::iterator non_primitive_begin = entries_.begin();
+ std::vector<const RegType*>::iterator non_primitive_begin = entries_.begin();
std::advance(non_primitive_begin, kNumPrimitivesAndSmallConstants);
STLDeleteContainerPointers(non_primitive_begin, entries_.end());
}
@@ -271,7 +272,7 @@
DoubleLoType::Destroy();
DoubleHiType::Destroy();
for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) {
- PreciseConstType* type = small_precise_constants_[value - kMinSmallConstant];
+ const PreciseConstType* type = small_precise_constants_[value - kMinSmallConstant];
delete type;
small_precise_constants_[value - kMinSmallConstant] = nullptr;
}
@@ -281,14 +282,14 @@
}
template <class Type>
-Type* RegTypeCache::CreatePrimitiveTypeInstance(const std::string& descriptor) {
- mirror::Class* klass = NULL;
+const Type* RegTypeCache::CreatePrimitiveTypeInstance(const std::string& descriptor) {
+ mirror::Class* klass = nullptr;
// Try loading the class from linker.
if (!descriptor.empty()) {
klass = art::Runtime::Current()->GetClassLinker()->FindSystemClass(Thread::Current(),
descriptor.c_str());
}
- Type* entry = Type::CreateInstance(klass, descriptor, RegTypeCache::primitive_count_);
+ const Type* entry = Type::CreateInstance(klass, descriptor, RegTypeCache::primitive_count_);
RegTypeCache::primitive_count_++;
return entry;
}
@@ -330,10 +331,10 @@
}
// Check if entry already exists.
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUnresolvedMergedReference()) {
std::set<uint16_t> cur_entry_types =
- (down_cast<UnresolvedMergedType*>(cur_entry))->GetMergedTypes();
+ (down_cast<const UnresolvedMergedType*>(cur_entry))->GetMergedTypes();
if (cur_entry_types == types) {
return *cur_entry;
}
@@ -353,10 +354,10 @@
const RegType& RegTypeCache::FromUnresolvedSuperClass(const RegType& child) {
// Check if entry already exists.
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUnresolvedSuperClass()) {
- UnresolvedSuperClass* tmp_entry =
- down_cast<UnresolvedSuperClass*>(cur_entry);
+ const UnresolvedSuperClass* tmp_entry =
+ down_cast<const UnresolvedSuperClass*>(cur_entry);
uint16_t unresolved_super_child_id =
tmp_entry->GetUnresolvedSuperClassChildId();
if (unresolved_super_child_id == child.GetId()) {
@@ -370,27 +371,28 @@
}
const UninitializedType& RegTypeCache::Uninitialized(const RegType& type, uint32_t allocation_pc) {
- UninitializedType* entry = NULL;
+ UninitializedType* entry = nullptr;
const std::string& descriptor(type.GetDescriptor());
if (type.IsUnresolvedTypes()) {
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUnresolvedAndUninitializedReference() &&
- down_cast<UnresolvedUninitializedRefType*>(cur_entry)->GetAllocationPc() == allocation_pc &&
+ down_cast<const UnresolvedUninitializedRefType*>(cur_entry)->GetAllocationPc()
+ == allocation_pc &&
(cur_entry->GetDescriptor() == descriptor)) {
- return *down_cast<UnresolvedUninitializedRefType*>(cur_entry);
+ return *down_cast<const UnresolvedUninitializedRefType*>(cur_entry);
}
}
entry = new UnresolvedUninitializedRefType(descriptor, allocation_pc, entries_.size());
} else {
mirror::Class* klass = type.GetClass();
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUninitializedReference() &&
- down_cast<UninitializedReferenceType*>(cur_entry)
+ down_cast<const UninitializedReferenceType*>(cur_entry)
->GetAllocationPc() == allocation_pc &&
cur_entry->GetClass() == klass) {
- return *down_cast<UninitializedReferenceType*>(cur_entry);
+ return *down_cast<const UninitializedReferenceType*>(cur_entry);
}
}
entry = new UninitializedReferenceType(klass, descriptor, allocation_pc, entries_.size());
@@ -405,7 +407,7 @@
if (uninit_type.IsUnresolvedTypes()) {
const std::string& descriptor(uninit_type.GetDescriptor());
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUnresolvedReference() &&
cur_entry->GetDescriptor() == descriptor) {
return *cur_entry;
@@ -417,7 +419,7 @@
if (uninit_type.IsUninitializedThisReference() && !klass->IsFinal()) {
// For uninitialized "this reference" look for reference types that are not precise.
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsReference() && cur_entry->GetClass() == klass) {
return *cur_entry;
}
@@ -427,7 +429,7 @@
// We're uninitialized because of allocation, look or create a precise type as allocations
// may only create objects of that type.
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) {
return *cur_entry;
}
@@ -441,61 +443,24 @@
return *entry;
}
-const ImpreciseConstType& RegTypeCache::ByteConstant() {
- const ConstantType& result = FromCat1Const(std::numeric_limits<jbyte>::min(), false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
-const ImpreciseConstType& RegTypeCache::CharConstant() {
- int32_t jchar_max = static_cast<int32_t>(std::numeric_limits<jchar>::max());
- const ConstantType& result = FromCat1Const(jchar_max, false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
-const ImpreciseConstType& RegTypeCache::ShortConstant() {
- const ConstantType& result = FromCat1Const(std::numeric_limits<jshort>::min(), false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
-const ImpreciseConstType& RegTypeCache::IntConstant() {
- const ConstantType& result = FromCat1Const(std::numeric_limits<jint>::max(), false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
-const ImpreciseConstType& RegTypeCache::PosByteConstant() {
- const ConstantType& result = FromCat1Const(std::numeric_limits<jbyte>::max(), false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
-const ImpreciseConstType& RegTypeCache::PosShortConstant() {
- const ConstantType& result = FromCat1Const(std::numeric_limits<jshort>::max(), false);
- DCHECK(result.IsImpreciseConstant());
- return *down_cast<const ImpreciseConstType*>(&result);
-}
-
const UninitializedType& RegTypeCache::UninitializedThisArgument(const RegType& type) {
UninitializedType* entry;
const std::string& descriptor(type.GetDescriptor());
if (type.IsUnresolvedTypes()) {
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUnresolvedAndUninitializedThisReference() &&
cur_entry->GetDescriptor() == descriptor) {
- return *down_cast<UninitializedType*>(cur_entry);
+ return *down_cast<const UninitializedType*>(cur_entry);
}
}
entry = new UnresolvedUninitializedThisRefType(descriptor, entries_.size());
} else {
mirror::Class* klass = type.GetClass();
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
- return *down_cast<UninitializedType*>(cur_entry);
+ return *down_cast<const UninitializedType*>(cur_entry);
}
}
entry = new UninitializedThisReferenceType(klass, descriptor, entries_.size());
@@ -506,11 +471,11 @@
const ConstantType& RegTypeCache::FromCat1NonSmallConstant(int32_t value, bool precise) {
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->klass_.IsNull() && cur_entry->IsConstant() &&
cur_entry->IsPreciseConstant() == precise &&
- (down_cast<ConstantType*>(cur_entry))->ConstantValue() == value) {
- return *down_cast<ConstantType*>(cur_entry);
+ (down_cast<const ConstantType*>(cur_entry))->ConstantValue() == value) {
+ return *down_cast<const ConstantType*>(cur_entry);
}
}
ConstantType* entry;
@@ -525,10 +490,10 @@
const ConstantType& RegTypeCache::FromCat2ConstLo(int32_t value, bool precise) {
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsConstantLo() && (cur_entry->IsPrecise() == precise) &&
- (down_cast<ConstantType*>(cur_entry))->ConstantValueLo() == value) {
- return *down_cast<ConstantType*>(cur_entry);
+ (down_cast<const ConstantType*>(cur_entry))->ConstantValueLo() == value) {
+ return *down_cast<const ConstantType*>(cur_entry);
}
}
ConstantType* entry;
@@ -543,10 +508,10 @@
const ConstantType& RegTypeCache::FromCat2ConstHi(int32_t value, bool precise) {
for (size_t i = primitive_count_; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
+ const RegType* cur_entry = entries_[i];
if (cur_entry->IsConstantHi() && (cur_entry->IsPrecise() == precise) &&
- (down_cast<ConstantType*>(cur_entry))->ConstantValueHi() == value) {
- return *down_cast<ConstantType*>(cur_entry);
+ (down_cast<const ConstantType*>(cur_entry))->ConstantValueHi() == value) {
+ return *down_cast<const ConstantType*>(cur_entry);
}
}
ConstantType* entry;
@@ -583,15 +548,15 @@
void RegTypeCache::Dump(std::ostream& os) {
for (size_t i = 0; i < entries_.size(); i++) {
- RegType* cur_entry = entries_[i];
- if (cur_entry != NULL) {
+ const RegType* cur_entry = entries_[i];
+ if (cur_entry != nullptr) {
os << i << ": " << cur_entry->Dump() << "\n";
}
}
}
void RegTypeCache::VisitRoots(RootCallback* callback, void* arg) {
- for (RegType* entry : entries_) {
+ for (const RegType* entry : entries_) {
entry->VisitRoots(callback, arg);
}
}