Remove the useless "suspend count already zero" message for new threads.
We can actually detect the expected case of this warning ourselves, and
not emit it. Then we can upgrade the WARNING to a FATAL.
I also tripped over the fact that the operator<< for Thread::State was out
of date, so I've moved the Thread enums up to namespace scope so the script
can automatically generate correct operator<< implementations for us. (All
the high-numbered thread states have been off by one for a couple of weeks.)
Change-Id: I5de573d33d641e5a3cba87b370e9620c8c66e633
diff --git a/build/Android.common.mk b/build/Android.common.mk
index f70a1ca..b272649 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -273,7 +273,8 @@
src/invoke_type.h \
src/jdwp/jdwp.h \
src/jdwp/jdwp_constants.h \
- src/mutex.h
+ src/mutex.h \
+ src/thread.h
LIBARTTEST_COMMON_SRC_FILES := \
test/StackWalk/stack_walk_jni.cc \
diff --git a/src/check_jni.cc b/src/check_jni.cc
index 1b28dd5..9ae3d47 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -54,7 +54,7 @@
if (vm->check_jni_abort_hook != NULL) {
vm->check_jni_abort_hook(vm->check_jni_abort_hook_data, os.str());
} else {
- self->SetState(Thread::kNative); // Ensure that we get a native stack trace for this thread.
+ self->SetState(kNative); // Ensure that we get a native stack trace for this thread.
LOG(FATAL) << os.str();
}
}
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 095c949..ae13908 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1187,7 +1187,7 @@
} else {
std::string class_name_string(DescriptorToDot(descriptor));
- ScopedThreadStateChange tsc(self, Thread::kNative);
+ ScopedThreadStateChange tsc(self, kNative);
JNIEnv* env = self->GetJniEnv();
ScopedLocalRef<jclass> c(env, AddLocalReference<jclass>(env, GetClassRoot(kJavaLangClassLoader)));
CHECK(c.get() != NULL);
@@ -2644,7 +2644,7 @@
}
Thread* self = Thread::Current();
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
bool success = InitializeClass(c, can_run_clinit, can_init_fields);
if (!success) {
CHECK(self->IsExceptionPending() || !can_run_clinit) << PrettyClass(c);
diff --git a/src/compiler.cc b/src/compiler.cc
index bac39ef..3980bac 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -943,10 +943,10 @@
if (worker->spawn_) {
runtime->AttachCurrentThread("Compiler Worker", true, NULL);
}
- Thread::Current()->SetState(Thread::kRunnable);
+ Thread::Current()->SetState(kRunnable);
worker->Run();
if (worker->spawn_) {
- Thread::Current()->SetState(Thread::kNative);
+ Thread::Current()->SetState(kNative);
runtime->DetachCurrentThread();
}
return NULL;
@@ -988,7 +988,7 @@
threads[0]->Go();
// Switch to kVmWait while we're blocked waiting for the other threads to finish.
- ScopedThreadStateChange tsc(self, Thread::kVmWait);
+ ScopedThreadStateChange tsc(self, kVmWait);
STLDeleteElements(&threads);
}
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index 071c0bd..e0a5704 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -142,7 +142,7 @@
// Set thread state to kNative
StoreToObjectOffset(thread_object_addr,
Thread::StateOffset().Int32Value(),
- irb_.getInt32(Thread::kNative));
+ irb_.getInt32(kNative));
// Get callee code_addr
llvm::Value* code_addr_ =
@@ -262,7 +262,7 @@
// Set thread state to kRunnable
StoreToObjectOffset(thread_object_addr,
Thread::StateOffset().Int32Value(),
- irb_.getInt32(Thread::kRunnable));
+ irb_.getInt32(kRunnable));
if (return_shorty == 'L') {
// If the return value is reference, it may point to SIRT, we should decode it.
diff --git a/src/dalvik_system_DexFile.cc b/src/dalvik_system_DexFile.cc
index 3ada9f4..96a1ac1 100644
--- a/src/dalvik_system_DexFile.cc
+++ b/src/dalvik_system_DexFile.cc
@@ -126,7 +126,7 @@
static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
jint cookie) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
const DexFile* dex_file = toDexFile(env, cookie);
if (dex_file == NULL) {
return NULL;
diff --git a/src/dalvik_system_VMRuntime.cc b/src/dalvik_system_VMRuntime.cc
index 030caed..140faff 100644
--- a/src/dalvik_system_VMRuntime.cc
+++ b/src/dalvik_system_VMRuntime.cc
@@ -47,7 +47,7 @@
}
static jobject VMRuntime_newNonMovableArray(JNIEnv* env, jobject, jclass javaElementClass, jint length) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
#ifdef MOVING_GARBAGE_COLLECTOR
// TODO: right now, we don't have a copying collector, so there's no need
// to do anything special here, but we ought to pass the non-movability
@@ -81,7 +81,7 @@
if (javaArray == NULL) { // Most likely allocation failed
return 0;
}
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Array* array = Decode<Array*>(env, javaArray);
if (!array->IsArrayInstance()) {
Thread::Current()->ThrowNewException("Ljava/lang/IllegalArgumentException;", "not an array");
diff --git a/src/debugger.cc b/src/debugger.cc
index 70f9c8e..fbcd420 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -418,7 +418,7 @@
// If a debugger has already attached, send the "welcome" message.
// This may cause us to suspend all threads.
if (gJdwpState->IsActive()) {
- //ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ //ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
if (!gJdwpState->PostVMStart()) {
LOG(WARNING) << "Failed to post 'start' message to debugger";
}
@@ -532,15 +532,15 @@
}
int Dbg::ThreadRunning() {
- return static_cast<int>(Thread::Current()->SetState(Thread::kRunnable));
+ return static_cast<int>(Thread::Current()->SetState(kRunnable));
}
int Dbg::ThreadWaiting() {
- return static_cast<int>(Thread::Current()->SetState(Thread::kVmWait));
+ return static_cast<int>(Thread::Current()->SetState(kVmWait));
}
int Dbg::ThreadContinuing(int new_state) {
- return static_cast<int>(Thread::Current()->SetState(static_cast<Thread::State>(new_state)));
+ return static_cast<int>(Thread::Current()->SetState(static_cast<ThreadState>(new_state)));
}
void Dbg::UndoDebuggerSuspensions() {
@@ -1388,15 +1388,15 @@
// TODO: if we're in Thread.sleep(long), we should return TS_SLEEPING,
// even if it's implemented using Object.wait(long).
switch (thread->GetState()) {
- case Thread::kTerminated: *pThreadStatus = JDWP::TS_ZOMBIE; break;
- case Thread::kRunnable: *pThreadStatus = JDWP::TS_RUNNING; break;
- case Thread::kTimedWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
- case Thread::kBlocked: *pThreadStatus = JDWP::TS_MONITOR; break;
- case Thread::kWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
- case Thread::kStarting: *pThreadStatus = JDWP::TS_ZOMBIE; break;
- case Thread::kNative: *pThreadStatus = JDWP::TS_RUNNING; break;
- case Thread::kVmWait: *pThreadStatus = JDWP::TS_WAIT; break;
- case Thread::kSuspended: *pThreadStatus = JDWP::TS_RUNNING; break;
+ case kTerminated: *pThreadStatus = JDWP::TS_ZOMBIE; break;
+ case kRunnable: *pThreadStatus = JDWP::TS_RUNNING; break;
+ case kTimedWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
+ case kBlocked: *pThreadStatus = JDWP::TS_MONITOR; break;
+ case kWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
+ case kStarting: *pThreadStatus = JDWP::TS_ZOMBIE; break;
+ case kNative: *pThreadStatus = JDWP::TS_RUNNING; break;
+ case kVmWait: *pThreadStatus = JDWP::TS_WAIT; break;
+ case kSuspended: *pThreadStatus = JDWP::TS_RUNNING; break;
// Don't add a 'default' here so the compiler can spot incompatible enum changes.
}
@@ -1524,7 +1524,7 @@
}
void Dbg::SuspendVM() {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable); // TODO: do we really want to change back? should the JDWP thread be Runnable usually?
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable); // TODO: do we really want to change back? should the JDWP thread be Runnable usually?
Runtime::Current()->GetThreadList()->SuspendAll(true);
}
@@ -2173,7 +2173,7 @@
* run out of memory. It's also a good idea to change it before locking
* the invokeReq mutex, although that should never be held for long.
*/
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
+ ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
VLOG(jdwp) << " Transferring control to event thread";
{
@@ -2232,7 +2232,7 @@
SirtRef<Throwable> old_exception(self->GetException());
self->ClearException();
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
// Translate the method through the vtable, unless the debugger wants to suppress it.
Method* m = pReq->method_;
@@ -2401,7 +2401,7 @@
VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
Thread* self = Thread::Current();
- if (self->GetState() != Thread::kRunnable) {
+ if (self->GetState() != kRunnable) {
LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
/* try anyway? */
}
diff --git a/src/heap.cc b/src/heap.cc
index 8a7ab3d..76a620e 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -427,7 +427,7 @@
// Since allocation can cause a GC which will need to SuspendAll,
// make sure all allocators are in the kRunnable state.
- CHECK_EQ(Thread::Current()->GetState(), Thread::kRunnable);
+ CHECK_EQ(Thread::Current()->GetState(), kRunnable);
// Fail impossible allocations
if (alloc_size > space->Capacity()) {
@@ -687,13 +687,13 @@
}
void Heap::Lock() {
- // Grab the lock, but put ourselves into Thread::kVmWait if it looks
+ // Grab the lock, but put ourselves into kVmWait if it looks
// like we're going to have to wait on the mutex. This prevents
// deadlock if another thread is calling CollectGarbageInternal,
// since they will have the heap lock and be waiting for mutators to
// suspend.
if (!lock_->TryLock()) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
+ ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
lock_->Lock();
}
}
@@ -786,7 +786,7 @@
}
void Heap::AddFinalizerReference(Thread* self, Object* object) {
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
static Method* FinalizerReference_add =
java_lang_ref_FinalizerReference_->FindDirectMethod("add", "(Ljava/lang/Object;)V");
DCHECK(FinalizerReference_add != NULL);
@@ -803,7 +803,7 @@
DCHECK(ReferenceQueue_add != NULL);
Thread* self = Thread::Current();
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
JValue args[1];
args[0].l = *cleared;
ReferenceQueue_add->Invoke(self, NULL, args, NULL);
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index ce3050e..b118b5c 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -759,7 +759,7 @@
int DumpHeap(const char* fileName, int fd, bool directToDdms) {
CHECK(fileName != NULL);
ScopedHeapLock heap_lock;
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
ThreadList* thread_list = Runtime::Current()->GetThreadList();
thread_list->SuspendAll();
diff --git a/src/java_lang_Class.cc b/src/java_lang_Class.cc
index 17b584a..c1d6eb0 100644
--- a/src/java_lang_Class.cc
+++ b/src/java_lang_Class.cc
@@ -39,7 +39,7 @@
// "name" is in "binary name" format, e.g. "dalvik.system.Debug$1".
static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize, jobject javaLoader) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
ScopedUtfChars name(env, javaName);
if (name.c_str() == NULL) {
return NULL;
@@ -133,7 +133,7 @@
}
static jobjectArray Class_getDeclaredFields(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* c = DecodeClass(env, javaClass);
if (c == NULL) {
return NULL;
@@ -187,7 +187,7 @@
}
static jobjectArray Class_getDeclaredMethods(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* c = DecodeClass(env, javaClass);
if (c == NULL) {
return NULL;
@@ -308,7 +308,7 @@
}
static jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass java_class, jobject jname) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* c = DecodeClass(env, java_class);
if (c == NULL) {
return NULL;
@@ -344,19 +344,19 @@
}
static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* c = DecodeClass(env, javaThis);
return AddLocalReference<jstring>(env, c->ComputeName());
}
static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(env, javaThis));
return AddLocalReference<jobjectArray>(env, c->GetInterfaces()->Clone());
}
static jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* lhs = DecodeClass(env, javaLhs);
Class* rhs = Decode<Class*>(env, javaRhs); // Can be null.
if (rhs == NULL) {
@@ -396,7 +396,7 @@
}
static jobject Class_newInstanceImpl(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* c = DecodeClass(env, javaThis);
if (c->IsPrimitive() || c->IsInterface() || c->IsArrayClass() || c->IsAbstract()) {
Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
diff --git a/src/java_lang_Object.cc b/src/java_lang_Object.cc
index f95d1a1..7c79fc1 100644
--- a/src/java_lang_Object.cc
+++ b/src/java_lang_Object.cc
@@ -22,7 +22,7 @@
namespace art {
static jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Object* o = Decode<Object*>(env, javaThis);
return AddLocalReference<jobject>(env, o->Clone());
}
diff --git a/src/java_lang_Runtime.cc b/src/java_lang_Runtime.cc
index 44703b7..1b5520b 100644
--- a/src/java_lang_Runtime.cc
+++ b/src/java_lang_Runtime.cc
@@ -28,7 +28,7 @@
namespace art {
static void Runtime_gc(JNIEnv*, jclass) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Runtime::Current()->GetHeap()->CollectGarbage(false);
}
diff --git a/src/java_lang_String.cc b/src/java_lang_String.cc
index 17dbbe9..49bf234 100644
--- a/src/java_lang_String.cc
+++ b/src/java_lang_String.cc
@@ -37,7 +37,7 @@
namespace art {
static jint String_compareTo(JNIEnv* env, jobject javaThis, jobject javaRhs) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
String* lhs = Decode<String*>(env, javaThis);
String* rhs = Decode<String*>(env, javaRhs);
diff --git a/src/java_lang_System.cc b/src/java_lang_System.cc
index fa8257b..741b319 100644
--- a/src/java_lang_System.cc
+++ b/src/java_lang_System.cc
@@ -109,7 +109,7 @@
}
static void System_arraycopy(JNIEnv* env, jclass, jobject javaSrc, jint srcPos, jobject javaDst, jint dstPos, jint length) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Thread* self = Thread::Current();
// Null pointer checks.
diff --git a/src/java_lang_Thread.cc b/src/java_lang_Thread.cc
index 6ce2609..197c1b9 100644
--- a/src/java_lang_Thread.cc
+++ b/src/java_lang_Thread.cc
@@ -54,22 +54,22 @@
const jint kJavaTimedWaiting = 4;
const jint kJavaTerminated = 5;
- Thread::State internal_thread_state = (hasBeenStarted ? Thread::kTerminated : Thread::kStarting);
+ ThreadState internal_thread_state = (hasBeenStarted ? kTerminated : kStarting);
ScopedThreadListLock thread_list_lock;
Thread* thread = Thread::FromManagedThread(env, javaThread);
if (thread != NULL) {
internal_thread_state = thread->GetState();
}
switch (internal_thread_state) {
- case Thread::kTerminated: return kJavaTerminated;
- case Thread::kRunnable: return kJavaRunnable;
- case Thread::kTimedWaiting: return kJavaTimedWaiting;
- case Thread::kBlocked: return kJavaBlocked;
- case Thread::kWaiting: return kJavaWaiting;
- case Thread::kStarting: return kJavaNew;
- case Thread::kNative: return kJavaRunnable;
- case Thread::kVmWait: return kJavaWaiting;
- case Thread::kSuspended: return kJavaRunnable;
+ case kTerminated: return kJavaTerminated;
+ case kRunnable: return kJavaRunnable;
+ case kTimedWaiting: return kJavaTimedWaiting;
+ case kBlocked: return kJavaBlocked;
+ case kWaiting: return kJavaWaiting;
+ case kStarting: return kJavaNew;
+ case kNative: return kJavaRunnable;
+ case kVmWait: return kJavaWaiting;
+ case kSuspended: return kJavaRunnable;
// Don't add a 'default' here so the compiler can spot incompatible enum changes.
}
return -1; // Unreachable.
@@ -78,7 +78,7 @@
static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject javaThread, jobject javaObject) {
Object* object = Decode<Object*>(env, javaObject);
if (object == NULL) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "object == null");
return JNI_FALSE;
}
diff --git a/src/java_lang_reflect_Array.cc b/src/java_lang_reflect_Array.cc
index 4a5f797..1c86aac 100644
--- a/src/java_lang_reflect_Array.cc
+++ b/src/java_lang_reflect_Array.cc
@@ -70,7 +70,7 @@
// subtract pieces off. Besides, we want to start with the outermost
// piece and work our way in.
static jobject Array_createMultiArray(JNIEnv* env, jclass, jclass javaElementClass, jobject javaDimArray) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
DCHECK(javaElementClass != NULL);
Class* element_class = Decode<Class*>(env, javaElementClass);
DCHECK(element_class->IsClass());
@@ -118,7 +118,7 @@
}
static jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementClass, jint length) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
DCHECK(javaElementClass != NULL);
Class* element_class = Decode<Class*>(env, javaElementClass);
if (length < 0) {
diff --git a/src/java_lang_reflect_Constructor.cc b/src/java_lang_reflect_Constructor.cc
index 9a498f4..5d0434d 100644
--- a/src/java_lang_reflect_Constructor.cc
+++ b/src/java_lang_reflect_Constructor.cc
@@ -32,7 +32,7 @@
* with an interface, array, or primitive class.
*/
static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Method* m = Decode<Object*>(env, javaMethod)->AsMethod();
Class* c = m->GetDeclaringClass();
if (c->IsAbstract()) {
diff --git a/src/java_lang_reflect_Field.cc b/src/java_lang_reflect_Field.cc
index a7785e7..a8bde03 100644
--- a/src/java_lang_reflect_Field.cc
+++ b/src/java_lang_reflect_Field.cc
@@ -25,7 +25,7 @@
namespace art {
static bool GetFieldValue(Object* o, Field* f, JValue& value, bool allow_references) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(), true, true)) {
return false;
}
@@ -206,7 +206,7 @@
}
static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Field* f = DecodeField(env->FromReflectedField(javaField));
// Unbox the value, if necessary.
@@ -227,7 +227,7 @@
static void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
const JValue& new_value) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Field* f = DecodeField(env->FromReflectedField(javaField));
Object* o = NULL;
if (!CheckReceiver(env, javaObj, f, o)) {
diff --git a/src/java_lang_reflect_Method.cc b/src/java_lang_reflect_Method.cc
index d9006dc..a5a705b 100644
--- a/src/java_lang_reflect_Method.cc
+++ b/src/java_lang_reflect_Method.cc
@@ -44,7 +44,7 @@
CHECK_NE(throws_index, -1);
ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
// Change thread state for allocation
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
return AddLocalReference<jobject>(env, declared_exceptions->Clone());
}
diff --git a/src/java_lang_reflect_Proxy.cc b/src/java_lang_reflect_Proxy.cc
index 7bc3e44..bac20b0 100644
--- a/src/java_lang_reflect_Proxy.cc
+++ b/src/java_lang_reflect_Proxy.cc
@@ -24,7 +24,7 @@
static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName, jobjectArray javaInterfaces, jobject javaLoader, jobjectArray javaMethods, jobjectArray javaThrows) {
// Allocates Class so transition thread state to runnable
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
String* name = Decode<String*>(env, javaName);
ObjectArray<Class>* interfaces = Decode<ObjectArray<Class>*>(env, javaInterfaces);
ClassLoader* loader = Decode<ClassLoader*>(env, javaLoader);
diff --git a/src/jdwp/jdwp_main.cc b/src/jdwp/jdwp_main.cc
index ec85aa8..138b60a 100644
--- a/src/jdwp/jdwp_main.cc
+++ b/src/jdwp/jdwp_main.cc
@@ -170,7 +170,7 @@
*/
if (options->suspend) {
{
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
+ ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
state->attach_cond_.Wait(state->attach_lock_);
state->attach_lock_.Unlock();
@@ -327,7 +327,7 @@
bool first = true;
while (!Dbg::IsDisposed()) {
// sanity check -- shouldn't happen?
- if (Thread::Current()->GetState() != Thread::kVmWait) {
+ if (Thread::Current()->GetState() != kVmWait) {
LOG(ERROR) << "JDWP thread no longer in VMWAIT (now " << Thread::Current()->GetState() << "); resetting";
Dbg::ThreadWaiting();
}
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 1757736..f8b7013 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -106,7 +106,7 @@
void Java_MyClassNatives_foo(JNIEnv* env, jobject thisObj) {
// 2 = SirtRef<ClassLoader> + thisObj
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -155,7 +155,7 @@
jint Java_MyClassNatives_fooI(JNIEnv* env, jobject thisObj, jint x) {
// 2 = SirtRef<ClassLoader> + thisObj
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -181,7 +181,7 @@
jint Java_MyClassNatives_fooII(JNIEnv* env, jobject thisObj, jint x, jint y) {
// 2 = SirtRef<ClassLoader> + thisObj
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -208,7 +208,7 @@
jlong Java_MyClassNatives_fooJJ(JNIEnv* env, jobject thisObj, jlong x, jlong y) {
// 2 = SirtRef<ClassLoader> + thisObj
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -236,7 +236,7 @@
jdouble Java_MyClassNatives_fooDD(JNIEnv* env, jobject thisObj, jdouble x, jdouble y) {
// 2 = SirtRef<ClassLoader> + thisObj
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -266,7 +266,7 @@
jobject z) {
// 4 = SirtRef<ClassLoader> + this + y + z
EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(thisObj != NULL);
EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
@@ -317,7 +317,7 @@
jint Java_MyClassNatives_fooSII(JNIEnv* env, jclass klass, jint x, jint y) {
// 2 = SirtRef<ClassLoader> + klass
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(klass != NULL);
EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -340,7 +340,7 @@
jdouble Java_MyClassNatives_fooSDD(JNIEnv* env, jclass klass, jdouble x, jdouble y) {
// 2 = SirtRef<ClassLoader> + klass
EXPECT_EQ(2U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(klass != NULL);
EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -369,7 +369,7 @@
jobject z) {
// 4 = SirtRef<ClassLoader> + klass + y + z
EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(klass != NULL);
EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
@@ -422,7 +422,7 @@
jobject z) {
// 4 = SirtRef<ClassLoader> + klass + y + z
EXPECT_EQ(4U, Thread::Current()->NumStackReferences());
- EXPECT_EQ(Thread::kNative, Thread::Current()->GetState());
+ EXPECT_EQ(kNative, Thread::Current()->GetState());
EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
EXPECT_TRUE(klass != NULL);
EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 6ac36bd..26f069c 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -586,7 +586,7 @@
while (jni_on_load_result_ == kPending) {
VLOG(jni) << "[" << *self << " waiting for \"" << path_ << "\" "
<< "JNI_OnLoad...]";
- ScopedThreadStateChange tsc(self, Thread::kVmWait);
+ ScopedThreadStateChange tsc(self, kVmWait);
jni_on_load_cond_.Wait(jni_on_load_lock_);
}
@@ -2847,7 +2847,7 @@
Thread* self = Thread::Current();
void* handle = NULL;
{
- ScopedThreadStateChange tsc(self, Thread::kVmWait);
+ ScopedThreadStateChange tsc(self, kVmWait);
handle = dlopen(path.empty() ? NULL : path.c_str(), RTLD_LAZY);
}
@@ -2890,7 +2890,7 @@
int version = 0;
{
- ScopedThreadStateChange tsc(self, Thread::kNative);
+ ScopedThreadStateChange tsc(self, kNative);
VLOG(jni) << "[Calling JNI_OnLoad in \"" << path << "\"]";
version = (*jni_on_load)(this, NULL);
}
diff --git a/src/monitor.cc b/src/monitor.cc
index dcb3c04..a42770e 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -190,7 +190,7 @@
const Method* current_locking_method = NULL;
uintptr_t current_locking_pc = 0;
{
- ScopedThreadStateChange tsc(self, Thread::kBlocked);
+ ScopedThreadStateChange tsc(self, kBlocked);
if (wait_threshold != 0) {
waitStart = NanoTime() / 1000;
}
@@ -441,9 +441,9 @@
* our suspend mode before we transition out.
*/
if (timed) {
- self->SetState(Thread::kTimedWaiting);
+ self->SetState(kTimedWaiting);
} else {
- self->SetState(Thread::kWaiting);
+ self->SetState(kWaiting);
}
self->wait_mutex_->Lock();
@@ -503,8 +503,8 @@
locking_pc_ = savedPc;
RemoveFromWaitSet(self);
- /* set self->status back to Thread::kRunnable, and self-suspend if needed */
- self->SetState(Thread::kRunnable);
+ /* set self->status back to kRunnable, and self-suspend if needed */
+ self->SetState(kRunnable);
if (wasInterrupted) {
/*
@@ -632,7 +632,7 @@
threadId, thinp, PrettyTypeOf(obj).c_str(), LW_LOCK_OWNER(thin));
// The lock is owned by another thread. Notify the runtime that we are about to wait.
self->monitor_enter_object_ = obj;
- Thread::State oldStatus = self->SetState(Thread::kBlocked);
+ ThreadState oldStatus = self->SetState(kBlocked);
// Spin until the thin lock is released or inflated.
sleepDelayNs = 0;
for (;;) {
@@ -696,7 +696,7 @@
volatile int32_t* thinp = obj->GetRawLockWordAddress();
DCHECK(self != NULL);
- //DCHECK_EQ(self->GetState(), Thread::kRunnable);
+ //DCHECK_EQ(self->GetState(), kRunnable);
DCHECK(obj != NULL);
/*
@@ -823,18 +823,18 @@
}
void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
- Thread::State state = thread->GetState();
+ ThreadState state = thread->GetState();
Object* object = NULL;
uint32_t lock_owner = ThreadList::kInvalidId;
- if (state == Thread::kWaiting || state == Thread::kTimedWaiting) {
+ if (state == kWaiting || state == kTimedWaiting) {
os << " - waiting on ";
Monitor* monitor = thread->wait_monitor_;
if (monitor != NULL) {
object = monitor->obj_;
}
lock_owner = Thread::LockOwnerFromThreadLock(object);
- } else if (state == Thread::kBlocked) {
+ } else if (state == kBlocked) {
os << " - waiting to lock ";
object = thread->monitor_enter_object_;
if (object != NULL) {
diff --git a/src/oat/jni/jni_compiler.cc b/src/oat/jni/jni_compiler.cc
index 4a186aa..c1ae664 100644
--- a/src/oat/jni/jni_compiler.cc
+++ b/src/oat/jni/jni_compiler.cc
@@ -34,7 +34,7 @@
namespace art {
-static void ChangeThreadState(Assembler* jni_asm, Thread::State new_state,
+static void ChangeThreadState(Assembler* jni_asm, ThreadState new_state,
ManagedRegister scratch, ManagedRegister return_reg,
FrameOffset return_save_location,
size_t return_size) {
@@ -42,19 +42,19 @@
* This code mirrors that of Thread::SetState where detail is given on why
* barriers occur when they do.
*/
- if (new_state == Thread::kRunnable) {
+ if (new_state == kRunnable) {
/*
- * Change our status to Thread::kRunnable. The transition requires
+ * Change our status to kRunnable. The transition requires
* that we check for pending suspension, because the runtime considers
* us to be "asleep" in all other states, and another thread could
* be performing a GC now.
*/
- __ StoreImmediateToThread(Thread::StateOffset(), Thread::kRunnable, scratch);
+ __ StoreImmediateToThread(Thread::StateOffset(), kRunnable, scratch);
__ MemoryBarrier(scratch);
__ SuspendPoll(scratch, return_reg, return_save_location, return_size);
} else {
/*
- * Not changing to Thread::kRunnable. No additional work required.
+ * Not changing to kRunnable. No additional work required.
*/
__ MemoryBarrier(scratch);
__ StoreImmediateToThread(Thread::StateOffset(), new_state, scratch);
@@ -264,7 +264,7 @@
__ StoreStackPointerToThread(Thread::TopOfManagedStackOffset());
__ StoreImmediateToThread(Thread::TopOfManagedStackPcOffset(), 0,
mr_conv->InterproceduralScratchRegister());
- ChangeThreadState(jni_asm.get(), Thread::kNative,
+ ChangeThreadState(jni_asm.get(), kNative,
mr_conv->InterproceduralScratchRegister(),
ManagedRegister::NoRegister(), FrameOffset(0), 0);
@@ -483,7 +483,7 @@
FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation();
CHECK(return_save_location.Uint32Value() < frame_size ||
jni_conv->SizeOfReturnValue() == 0);
- ChangeThreadState(jni_asm.get(), Thread::kRunnable,
+ ChangeThreadState(jni_asm.get(), kRunnable,
jni_conv->InterproceduralScratchRegister(),
jni_conv->ReturnRegister(), return_save_location,
jni_conv->SizeOfReturnValue());
diff --git a/src/object.cc b/src/object.cc
index f2bddc3..74195f8 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -559,7 +559,7 @@
void Method::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const {
// Push a transition back into managed code onto the linked list in thread.
- CHECK_EQ(Thread::kRunnable, self->GetState());
+ CHECK_EQ(kRunnable, self->GetState());
#if !defined(ART_USE_LLVM_COMPILER)
NativeToManagedRecord record;
diff --git a/src/reflection.cc b/src/reflection.cc
index 008c1cd..f7c275c 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -48,7 +48,7 @@
jobject InvokeMethod(JNIEnv* env, jobject javaMethod, jobject javaReceiver, jobject javaArgs) {
Thread* self = Thread::Current();
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
jmethodID mid = env->FromReflectedMethod(javaMethod);
Method* m = reinterpret_cast<Method*>(mid);
@@ -269,7 +269,7 @@
}
Thread* self = Thread::Current();
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
JValue args[1] = { value };
m->Invoke(self, NULL, args, &value);
}
diff --git a/src/runtime.cc b/src/runtime.cc
index 1d0ab8f..12f7c8b 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -175,7 +175,7 @@
void Runtime::CallExitHook(jint status) {
if (exit_ != NULL) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kNative);
+ ScopedThreadStateChange tsc(Thread::Current(), kNative);
exit_(status);
LOG(WARNING) << "Exit hook returned instead of exiting!";
}
@@ -499,7 +499,7 @@
Thread* self = Thread::Current();
// Must be in the kNative state for calling native methods.
- CHECK_EQ(self->GetState(), Thread::kNative);
+ CHECK_EQ(self->GetState(), kNative);
JNIEnv* env = self->GetJniEnv();
ScopedLocalRef<jclass> ClassLoader_class(env, env->FindClass("java/lang/ClassLoader"));
@@ -533,7 +533,7 @@
class_linker_->RelocateExecutable();
// Restore main thread state to kNative as expected by native code
- Thread::Current()->SetState(Thread::kNative);
+ Thread::Current()->SetState(kNative);
started_ = true;
@@ -578,7 +578,7 @@
Thread* self = Thread::Current();
// Must be in the kNative state for calling native methods.
- CHECK_EQ(self->GetState(), Thread::kNative);
+ CHECK_EQ(self->GetState(), kNative);
JNIEnv* env = self->GetJniEnv();
ScopedLocalRef<jclass> c(env, env->FindClass("java/lang/Daemons"));
@@ -649,7 +649,7 @@
Thread::Attach("main", false, NULL);
// Set us to runnable so tools using a runtime can allocate and GC by default
- Thread::Current()->SetState(Thread::kRunnable);
+ Thread::Current()->SetState(kRunnable);
// Now we're attached, we can take the heap lock and validate the heap.
GetHeap()->EnableObjectValidation();
@@ -682,7 +682,7 @@
JNIEnv* env = self->GetJniEnv();
// Must be in the kNative state for calling native methods (JNI_OnLoad code).
- CHECK_EQ(self->GetState(), Thread::kNative);
+ CHECK_EQ(self->GetState(), kNative);
// First set up JniConstants, which is used by both the runtime's built-in native
// methods and libcore.
diff --git a/src/scoped_jni_thread_state.h b/src/scoped_jni_thread_state.h
index 1065a96..fdf6581 100644
--- a/src/scoped_jni_thread_state.h
+++ b/src/scoped_jni_thread_state.h
@@ -28,7 +28,7 @@
explicit ScopedJniThreadState(JNIEnv* env)
: env_(reinterpret_cast<JNIEnvExt*>(env)) {
self_ = ThreadForEnv(env);
- old_thread_state_ = self_->SetState(Thread::kRunnable);
+ old_thread_state_ = self_->SetState(kRunnable);
self_->VerifyStack();
}
@@ -64,7 +64,7 @@
JNIEnvExt* env_;
Thread* self_;
- Thread::State old_thread_state_;
+ ThreadState old_thread_state_;
DISALLOW_COPY_AND_ASSIGN(ScopedJniThreadState);
};
diff --git a/src/scoped_thread_list_lock.cc b/src/scoped_thread_list_lock.cc
index b999c3b..269c97e 100644
--- a/src/scoped_thread_list_lock.cc
+++ b/src/scoped_thread_list_lock.cc
@@ -32,7 +32,7 @@
// Self may be null during shutdown, but in that case there's no point going to kVmWait.
thread_list->thread_list_lock_.Lock();
} else {
- Thread::State old_thread_state = self->SetState(Thread::kVmWait);
+ ThreadState old_thread_state = self->SetState(kVmWait);
thread_list->thread_list_lock_.Lock();
// If we have the lock, by definition there's no GC in progress (though we
// might be taking the lock in order to start one). We avoid the suspend
diff --git a/src/signal_catcher.cc b/src/signal_catcher.cc
index aad6a08..be21372 100644
--- a/src/signal_catcher.cc
+++ b/src/signal_catcher.cc
@@ -77,7 +77,7 @@
return;
}
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
+ ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
int fd = open(stack_trace_file_.c_str(), O_APPEND | O_CREAT | O_WRONLY, 0666);
if (fd == -1) {
PLOG(ERROR) << "Unable to open stack trace file '" << stack_trace_file_ << "'";
@@ -136,7 +136,7 @@
}
int SignalCatcher::WaitForSignal(sigset_t& mask) {
- ScopedThreadStateChange tsc(thread_, Thread::kVmWait);
+ ScopedThreadStateChange tsc(thread_, kVmWait);
// Signals for sigwait() must be blocked but not ignored. We
// block signals like SIGQUIT for all threads, so the condition
@@ -168,7 +168,7 @@
Runtime* runtime = Runtime::Current();
runtime->AttachCurrentThread("Signal Catcher", true, Thread::GetSystemThreadGroup());
- Thread::Current()->SetState(Thread::kRunnable);
+ Thread::Current()->SetState(kRunnable);
{
MutexLock mu(signal_catcher->lock_);
diff --git a/src/sun_misc_Unsafe.cc b/src/sun_misc_Unsafe.cc
index d5d7444..214771b 100644
--- a/src/sun_misc_Unsafe.cc
+++ b/src/sun_misc_Unsafe.cc
@@ -30,7 +30,7 @@
static jint Unsafe_arrayBaseOffset0(JNIEnv* env, jclass, jclass javaArrayClass) {
// TODO: move to Java code
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Class* array_class = Decode<Class*>(env, javaArrayClass);
return Array::DataOffset(array_class->GetComponentSize()).Int32Value();
}
diff --git a/src/thread.cc b/src/thread.cc
index 00b5188..b26928f 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -113,7 +113,7 @@
runtime->GetThreadList()->WaitForGo();
{
- CHECK_EQ(self->GetState(), Thread::kRunnable);
+ CHECK_EQ(self->GetState(), kRunnable);
SirtRef<String> thread_name(self->GetThreadName());
self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
}
@@ -179,7 +179,7 @@
SetVmData(peer, native_thread);
{
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
+ ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
pthread_t new_pthread;
pthread_attr_t attr;
CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
@@ -223,7 +223,7 @@
Thread* self = new Thread;
self->Init();
- self->SetState(Thread::kNative);
+ self->SetState(kNative);
// If we're the main thread, ClassLinker won't be created until after we're attached,
// so that thread needs a two-stage attach. Regular threads don't need this hack.
@@ -534,21 +534,21 @@
void Thread::DumpStack(std::ostream& os) const {
// If we're currently in native code, dump that stack before dumping the managed stack.
- if (GetState() == Thread::kNative || GetState() == Thread::kVmWait) {
+ if (GetState() == kNative || GetState() == kVmWait) {
DumpNativeStack(os);
}
StackDumpVisitor dumper(os, this);
WalkStack(&dumper);
}
-void Thread::SetStateWithoutSuspendCheck(Thread::State new_state) {
+void Thread::SetStateWithoutSuspendCheck(ThreadState new_state) {
volatile void* raw = reinterpret_cast<volatile void*>(&state_);
volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
android_atomic_release_store(new_state, addr);
}
-Thread::State Thread::SetState(Thread::State new_state) {
- Thread::State old_state = state_;
+ThreadState Thread::SetState(ThreadState new_state) {
+ ThreadState old_state = state_;
if (old_state == new_state) {
return old_state;
}
@@ -556,9 +556,9 @@
volatile void* raw = reinterpret_cast<volatile void*>(&state_);
volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
- if (new_state == Thread::kRunnable) {
+ if (new_state == kRunnable) {
/*
- * Change our status to Thread::kRunnable. The transition requires
+ * Change our status to kRunnable. The transition requires
* that we check for pending suspension, because the runtime considers
* us to be "asleep" in all other states, and another thread could
* be performing a GC now.
@@ -616,7 +616,7 @@
}
} else {
/*
- * Not changing to Thread::kRunnable. No additional work required.
+ * Not changing to kRunnable. No additional work required.
*
* We use a releasing store to ensure that, if we were runnable,
* any updates we previously made to objects on the managed heap
@@ -632,7 +632,7 @@
ANNOTATE_IGNORE_READS_BEGIN();
int suspend_count = suspend_count_;
ANNOTATE_IGNORE_READS_END();
- return suspend_count != 0 && GetState() != Thread::kRunnable;
+ return suspend_count != 0 && GetState() != kRunnable;
}
static void ReportThreadSuspendTimeout(Thread* waiting_thread) {
@@ -650,7 +650,7 @@
useconds_t total_delay = 0;
useconds_t delay = 0;
- while (GetState() == Thread::kRunnable) {
+ while (GetState() == kRunnable) {
if (total_delay >= kTimeoutUs) {
ReportThreadSuspendTimeout(this);
}
@@ -715,7 +715,7 @@
Thread* self = Thread::Current();
// Need to be kRunnable for FindClass
- ScopedThreadStateChange tsc(self, Thread::kRunnable);
+ ScopedThreadStateChange tsc(self, kRunnable);
// Now the ClassLinker is ready, we can find the various Class*, Field*, and Method*s we need.
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -787,7 +787,7 @@
top_sirt_(NULL),
top_shadow_frame_(NULL),
jni_env_(NULL),
- state_(Thread::kNative),
+ state_(kNative),
self_(NULL),
runtime_(NULL),
exception_(NULL),
@@ -821,7 +821,7 @@
Thread* self = this;
// We may need to call user-supplied managed code.
- SetState(Thread::kRunnable);
+ SetState(kRunnable);
HandleUncaughtExceptions();
RemoveFromThreadGroup();
@@ -847,7 +847,7 @@
delete jni_env_;
jni_env_ = NULL;
- SetState(Thread::kTerminated);
+ SetState(kTerminated);
delete wait_cond_;
delete wait_mutex_;
@@ -1737,28 +1737,6 @@
}
#endif
-static const char* kStateNames[] = {
- "Terminated",
- "Runnable",
- "TimedWaiting",
- "Blocked",
- "Waiting",
- "Initializing",
- "Starting",
- "Native",
- "VmWait",
- "Suspended",
-};
-std::ostream& operator<<(std::ostream& os, const Thread::State& state) {
- int32_t int_state = static_cast<int32_t>(state);
- if (state >= Thread::kTerminated && state <= Thread::kSuspended) {
- os << kStateNames[int_state];
- } else {
- os << "State[" << int_state << "]";
- }
- return os;
-}
-
std::ostream& operator<<(std::ostream& os, const Thread& thread) {
thread.Dump(os, false);
return os;
diff --git a/src/thread.h b/src/thread.h
index a6459c6..ad15c0f 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -63,29 +63,28 @@
template<class T> class PrimitiveArray;
typedef PrimitiveArray<int32_t> IntArray;
+// Thread priorities. These must match the Thread.MIN_PRIORITY,
+// Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
+enum ThreadPriority {
+ kMinThreadPriority = 1,
+ kNormThreadPriority = 5,
+ kMaxThreadPriority = 10,
+};
+
+enum ThreadState {
+ kTerminated = 0, // Thread.TERMINATED JDWP TS_ZOMBIE
+ kRunnable = 1, // Thread.RUNNABLE JDWP TS_RUNNING
+ kTimedWaiting = 2, // Thread.TIMED_WAITING JDWP TS_WAIT - in Object.wait() with a timeout
+ kBlocked = 3, // Thread.BLOCKED JDWP TS_MONITOR - blocked on a monitor
+ kWaiting = 4, // Thread.WAITING JDWP TS_WAIT - in Object.wait()
+ kStarting = 5, // Thread.NEW - native thread started, not yet ready to run managed code
+ kNative = 6, // - running in a JNI native method
+ kVmWait = 7, // - waiting on an internal runtime resource
+ kSuspended = 8, // - suspended by GC or debugger
+};
+
class PACKED Thread {
public:
- // Thread priorities. These must match the Thread.MIN_PRIORITY,
- // Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
- enum Priority {
- kMinPriority = 1,
- kNormPriority = 5,
- kMaxPriority = 10,
- };
-
- // Thread states.
- enum State {
- kTerminated = 0, // Thread.TERMINATED JDWP TS_ZOMBIE
- kRunnable = 1, // Thread.RUNNABLE JDWP TS_RUNNING
- kTimedWaiting = 2, // Thread.TIMED_WAITING JDWP TS_WAIT - in Object.wait() with a timeout
- kBlocked = 3, // Thread.BLOCKED JDWP TS_MONITOR - blocked on a monitor
- kWaiting = 4, // Thread.WAITING JDWP TS_WAIT - in Object.wait()
- kStarting = 5, // Thread.NEW - native thread started, not yet ready to run managed code
- kNative = 6, // - running in a JNI native method
- kVmWait = 7, // - waiting on an internal runtime resource
- kSuspended = 8, // - suspended by GC or debugger
- };
-
// Space to throw a StackOverflowError in.
#if !defined(ART_USE_LLVM_COMPILER)
static const size_t kStackOverflowReservedBytes = 4 * KB;
@@ -126,12 +125,12 @@
// When full == false, dumps a one-line summary of thread state (used for operator<<).
void Dump(std::ostream& os, bool full = true) const;
- State GetState() const {
+ ThreadState GetState() const {
return state_;
}
- State SetState(State new_state);
- void SetStateWithoutSuspendCheck(State new_state);
+ ThreadState SetState(ThreadState new_state);
+ void SetStateWithoutSuspendCheck(ThreadState new_state);
bool IsDaemon();
bool IsSuspended();
@@ -572,7 +571,7 @@
// Every thread may have an associated JNI environment
JNIEnvExt* jni_env_;
- volatile State state_;
+ volatile ThreadState state_;
// Initialized to "this". On certain architectures (such as x86) reading
// off of Thread::Current is easy but getting the address of Thread::Current
@@ -627,11 +626,11 @@
};
std::ostream& operator<<(std::ostream& os, const Thread& thread);
-std::ostream& operator<<(std::ostream& os, const Thread::State& state);
+std::ostream& operator<<(std::ostream& os, const ThreadState& state);
class ScopedThreadStateChange {
public:
- ScopedThreadStateChange(Thread* thread, Thread::State new_state) : thread_(thread) {
+ ScopedThreadStateChange(Thread* thread, ThreadState new_state) : thread_(thread) {
old_thread_state_ = thread_->SetState(new_state);
}
@@ -641,7 +640,7 @@
private:
Thread* thread_;
- Thread::State old_thread_state_;
+ ThreadState old_thread_state_;
DISALLOW_COPY_AND_ASSIGN(ScopedThreadStateChange);
};
diff --git a/src/thread_android.cc b/src/thread_android.cc
index 6f80333..d26f446 100644
--- a/src/thread_android.cc
+++ b/src/thread_android.cc
@@ -73,18 +73,18 @@
int native_priority = getpriority(PRIO_PROCESS, 0);
if (native_priority == -1 && errno != 0) {
PLOG(WARNING) << "getpriority failed";
- return Thread::kNormPriority;
+ return kNormThreadPriority;
}
- int managed_priority = Thread::kMinPriority;
+ int managed_priority = kMinThreadPriority;
for (size_t i = 0; i < arraysize(kNiceValues); i++) {
if (native_priority >= kNiceValues[i]) {
break;
}
managed_priority++;
}
- if (managed_priority > Thread::kMaxPriority) {
- managed_priority = Thread::kMaxPriority;
+ if (managed_priority > kMaxThreadPriority) {
+ managed_priority = kMaxThreadPriority;
}
return managed_priority;
}
diff --git a/src/thread_linux.cc b/src/thread_linux.cc
index 50db13c..314668d 100644
--- a/src/thread_linux.cc
+++ b/src/thread_linux.cc
@@ -27,7 +27,7 @@
}
int Thread::GetNativePriority() {
- return Thread::kNormPriority;
+ return kNormThreadPriority;
}
} // namespace art
diff --git a/src/thread_list.cc b/src/thread_list.cc
index 2526fc2..1a342da 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -74,8 +74,10 @@
DCHECK_GE(thread->suspend_count_, thread->debug_suspend_count_) << *thread;
#endif
if (delta == -1 && thread->suspend_count_ <= 0) {
- // This can happen if you attach a thread during a GC.
- LOG(WARNING) << *thread << " suspend count already zero";
+ // This is expected if you attach a thread during a GC.
+ if (thread->GetState() != kStarting) {
+ LOG(FATAL) << *thread << " suspend count already zero";
+ }
return;
}
thread->suspend_count_ += delta;
@@ -95,7 +97,7 @@
VLOG(threads) << *thread << " self-suspending";
{
- ScopedThreadStateChange tsc(thread, Thread::kSuspended);
+ ScopedThreadStateChange tsc(thread, kSuspended);
while (thread->suspend_count_ != 0) {
/*
* Wait for wakeup signal, releasing lock. The act of releasing
@@ -114,7 +116,7 @@
VLOG(threads) << *self << " SuspendAll starting..." << (for_debugger ? " (debugger)" : "");
- CHECK_EQ(self->GetState(), Thread::kRunnable);
+ CHECK_EQ(self->GetState(), kRunnable);
ScopedThreadListLock thread_list_lock;
Thread* debug_thread = Dbg::GetDebugThread();
@@ -195,7 +197,7 @@
// Suspend ourselves.
CHECK_GT(self->suspend_count_, 0);
- self->SetState(Thread::kSuspended);
+ self->SetState(kSuspended);
VLOG(threads) << *self << " self-suspending (debugger)";
// Tell JDWP that we've completed suspension. The JDWP thread can't
@@ -215,7 +217,7 @@
}
}
CHECK_EQ(self->suspend_count_, 0);
- self->SetState(Thread::kRunnable);
+ self->SetState(kRunnable);
VLOG(threads) << *self << " self-reviving (debugger)";
}
@@ -387,19 +389,19 @@
VLOG(threads) << *self << " waiting for child " << *child << " to be in thread list...";
// We wait for the child to tell us that it's in the thread list.
- while (child->GetState() != Thread::kStarting) {
+ while (child->GetState() != kStarting) {
thread_start_cond_.Wait(thread_list_lock_);
}
}
// If we switch out of runnable and then back in, we know there's no pending suspend.
- self->SetState(Thread::kVmWait);
- self->SetState(Thread::kRunnable);
+ self->SetState(kVmWait);
+ self->SetState(kRunnable);
// Tell the child that it's safe: it will see any future suspend request.
ScopedThreadListLock thread_list_lock;
VLOG(threads) << *self << " telling child " << *child << " it's safe to proceed...";
- child->SetState(Thread::kVmWait);
+ child->SetState(kVmWait);
thread_start_cond_.Broadcast();
}
@@ -412,13 +414,13 @@
// Tell our parent that we're in the thread list.
VLOG(threads) << *self << " telling parent that we're now in thread list...";
- self->SetState(Thread::kStarting);
+ self->SetState(kStarting);
thread_start_cond_.Broadcast();
// Wait until our parent tells us there's no suspend still pending
// from before we were on the thread list.
VLOG(threads) << *self << " waiting for parent's go-ahead...";
- while (self->GetState() != Thread::kVmWait) {
+ while (self->GetState() != kVmWait) {
thread_start_cond_.Wait(thread_list_lock_);
}
}
@@ -432,7 +434,7 @@
{
ScopedHeapLock heap_lock;
}
- self->SetState(Thread::kRunnable);
+ self->SetState(kRunnable);
}
bool ThreadList::AllOtherThreadsAreDaemons() {
@@ -475,7 +477,7 @@
bool all_suspended = true;
for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
Thread* thread = *it;
- if (thread != Thread::Current() && thread->GetState() == Thread::kRunnable) {
+ if (thread != Thread::Current() && thread->GetState() == kRunnable) {
if (!have_complained) {
LOG(WARNING) << "daemon thread not yet suspended: " << *thread;
have_complained = true;
diff --git a/src/trace.cc b/src/trace.cc
index 3b4c3e5..3278830 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -200,7 +200,7 @@
return;
}
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Runtime::Current()->GetThreadList()->SuspendAll(false);
// Open trace file if not going directly to ddms.
@@ -240,7 +240,7 @@
return;
}
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
Runtime::Current()->GetThreadList()->SuspendAll(false);
Runtime::Current()->GetTracer()->FinishTracing();
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 3a16833..0370ead 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -63,7 +63,7 @@
// Enable this to dump reference map to LOG(INFO)
if (false) {
- ScopedThreadStateChange tsc(Thread::Current(), Thread::kRunnable);
+ ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
art::verifier::DexVerifier::VerifyMethodAndDump(m);
}
const uint8_t* ref_bitmap = NULL;
