Add more functionality to the thread and mutex implementation.
Change-Id: I33b2e53acb4c4c6653f13f1bbdd77cc7ce27e581
diff --git a/src/thread.h b/src/thread.h
index b1bfb33..6cc2135 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -4,6 +4,9 @@
#ifndef ART_SRC_THREAD_H_
#define ART_SRC_THREAD_H_
+#include <list>
+#include <pthread.h>
+
#include "src/globals.h"
#include "src/logging.h"
#include "src/macros.h"
@@ -11,22 +14,26 @@
namespace art {
class Object;
+class Runtime;
class Thread;
+class ThreadList;
class Mutex {
public:
virtual ~Mutex() {}
- void Lock() {}
+ void Lock();
- bool TryLock() { return true; }
+ bool TryLock();
- void Unlock() {}
+ void Unlock();
const char* GetName() { return name_; }
Thread* GetOwner() { return owner_; }
+ static Mutex* Create(const char* name);
+
public: // TODO: protected
explicit Mutex(const char* name) : name_(name), owner_(NULL) {}
@@ -37,6 +44,8 @@
Thread* owner_;
+ pthread_mutex_t lock_impl_;
+
DISALLOW_COPY_AND_ASSIGN(Mutex);
};
@@ -53,13 +62,29 @@
class Thread {
public:
- static Thread* Self() {
+ enum State {
+ kUnknown = -1,
+ kNew,
+ kRunnable,
+ kBlocked,
+ kWaiting,
+ kTimedWaiting,
+ kTerminated,
+ };
+
+ static Thread* Create(const char* name);
+
+ static Thread* Current() {
static Thread self;
return &self; // TODO
}
- uint32_t GetThreadId() {
- return thread_id_;
+ uint32_t GetId() const {
+ return id_;
+ }
+
+ pid_t GetNativeId() const {
+ return native_id_;
}
bool IsExceptionPending() const {
@@ -80,17 +105,118 @@
exception_ = NULL;
}
+ void SetName(const char* name);
+
+ void Suspend();
+
+ bool IsSuspended();
+
+ void Resume();
+
+ static bool Init();
+
+ Thread* next_;
+
+ Thread* prev_;
+
+ State GetState() {
+ return state_;
+ }
+
+ void SetState(State new_state) {
+ state_ = new_state;
+ }
+
private:
- Thread() : thread_id_(1234), exception_(NULL) {}
+ Thread() : id_(1234), exception_(NULL) {}
~Thread() {}
- uint32_t thread_id_;
+ State state_;
+
+ uint32_t id_;
+
+ pid_t native_id_;
+
+ pthread_t native_handle_;
Object* exception_;
+ static pthread_key_t pthread_key_self_;
+
DISALLOW_COPY_AND_ASSIGN(Thread);
};
+class ThreadList {
+ public:
+ static const int kMaxThreadId = 0xFFFF;
+ static const int kMainThreadId = 1;
+
+ void Init(Runtime* runtime);
+
+ void Register(Thread* thread);
+
+ void Unregister(Thread* thread);
+
+ void SuspendAll();
+
+ void ResumeAll();
+
+ ~ThreadList();
+
+ void Lock() {
+ lock_->Lock();
+ }
+
+ void Unlock() {
+ lock_->Unlock();
+ };
+
+ private:
+ ThreadList();
+
+ std::list<Thread*> list_;
+
+ Mutex* lock_;
+
+ DISALLOW_COPY_AND_ASSIGN(ThreadList);
+};
+
+class ThreadListLock {
+ public:
+ ThreadListLock(ThreadList* thread_list, Thread* current_thread)
+ : thread_list_(thread_list) {
+ if (current_thread == NULL) { // try to get it from TLS
+ current_thread = Thread::Current();
+ }
+ Thread::State old_state;
+ if (current_thread != NULL) {
+ old_state = current_thread->GetState();
+ current_thread->SetState(Thread::kWaiting); // TODO: VMWAIT
+ } else {
+ // happens during VM shutdown
+ old_state = Thread::kUnknown; // TODO: something else
+ }
+ thread_list_->Lock();
+ if (current_thread != NULL) {
+ current_thread->SetState(old_state);
+ }
+ }
+
+ ~ThreadListLock() {
+ thread_list_->Unlock();
+ }
+
+ // Allocates
+ int AllocThreadId();
+
+ void FreeThreadId(int thread_id);
+
+ private:
+ ThreadList* thread_list_;
+
+ DISALLOW_COPY_AND_ASSIGN(ThreadListLock);
+};
+
} // namespace art
#endif // ART_SRC_THREAD_H_