Various bits of cleanup.
Most notable: PrettyField now includes the type (but, like PrettyMethod,
lets you turn this off), and there's a new PrettyClass, and PrettyType
has been renamed to PrettyTypeOf.
I've also moved the dalvik "sync" stuff into files named "monitor", and
made some of the implementation details private.
Change-Id: I39ea79b45e173f9ebbf9878bcead207766a5653f
diff --git a/src/monitor.h b/src/monitor.h
new file mode 100644
index 0000000..8c22fb1
--- /dev/null
+++ b/src/monitor.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ART_SRC_MONITOR_H_
+#define ART_SRC_MONITOR_H_
+
+#include <pthread.h>
+#include <stdint.h>
+
+#include "mutex.h"
+
+namespace art {
+
+/*
+ * Monitor shape field. Used to distinguish thin locks from fat locks.
+ */
+#define LW_SHAPE_THIN 0
+#define LW_SHAPE_FAT 1
+#define LW_SHAPE_MASK 0x1
+#define LW_SHAPE(x) ((x) & LW_SHAPE_MASK)
+
+/*
+ * Hash state field. Used to signify that an object has had its
+ * identity hash code exposed or relocated.
+ */
+#define LW_HASH_STATE_UNHASHED 0
+#define LW_HASH_STATE_HASHED 1
+#define LW_HASH_STATE_HASHED_AND_MOVED 3
+#define LW_HASH_STATE_MASK 0x3
+#define LW_HASH_STATE_SHIFT 1
+#define LW_HASH_STATE(x) (((x) >> LW_HASH_STATE_SHIFT) & LW_HASH_STATE_MASK)
+
+/*
+ * Lock owner field. Contains the thread id of the thread currently
+ * holding the lock.
+ */
+#define LW_LOCK_OWNER_MASK 0xffff
+#define LW_LOCK_OWNER_SHIFT 3
+#define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK)
+
+class Object;
+class Thread;
+
+class Monitor {
+ public:
+ ~Monitor();
+
+ static uint32_t GetLockOwner(uint32_t raw_lock_word);
+
+ static void MonitorEnter(Thread* thread, Object* obj);
+ static bool MonitorExit(Thread* thread, Object* obj);
+
+ static void Notify(Thread* self, Object* obj);
+ static void NotifyAll(Thread* self, Object* obj);
+ static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow);
+
+ static void SweepMonitorList(bool (isUnmarkedObject)(void*));
+
+ static void FreeMonitorList();
+
+ private:
+ Monitor(Object* obj);
+
+ void AppendToWaitSet(Thread* thread);
+ void RemoveFromWaitSet(Thread* thread);
+
+ static void Inflate(Thread* self, Object* obj);
+
+ void Lock(Thread* self);
+ bool Unlock(Thread* thread);
+
+ void Notify(Thread* self);
+ void NotifyAll(Thread* self);
+
+ void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow);
+
+ /* Which thread currently owns the lock? */
+ Thread* owner_;
+
+ /* Owner's recursive lock depth */
+ int lock_count_;
+
+ /* What object are we part of (for debugging). */
+ Object* obj_;
+
+ /* Threads currently waiting on this monitor. */
+ Thread* wait_set_;
+
+ Mutex lock_;
+
+ Monitor* next_;
+
+ /*
+ * Who last acquired this monitor, when lock sampling is enabled.
+ * Even when enabled, ownerFileName may be NULL.
+ */
+ const char* owner_filename_;
+ uint32_t owner_line_number_;
+
+ friend class Object;
+};
+
+/*
+ * Relative timed wait on condition
+ */
+int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex, int64_t msec, int32_t nsec);
+
+} // namespace art
+
+#endif // ART_SRC_MONITOR_H_