Home | History | Annotate | Download | only in runtime
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ART_RUNTIME_MONITOR_H_
     18 #define ART_RUNTIME_MONITOR_H_
     19 
     20 #include <pthread.h>
     21 #include <stdint.h>
     22 
     23 #include <iosfwd>
     24 #include <list>
     25 #include <vector>
     26 
     27 #include "atomic.h"
     28 #include "base/allocator.h"
     29 #include "base/mutex.h"
     30 #include "gc_root.h"
     31 #include "object_callbacks.h"
     32 #include "read_barrier_option.h"
     33 #include "thread_state.h"
     34 
     35 namespace art {
     36 
     37 class LockWord;
     38 template<class T> class Handle;
     39 class Thread;
     40 class StackVisitor;
     41 typedef uint32_t MonitorId;
     42 
     43 namespace mirror {
     44   class ArtMethod;
     45   class Object;
     46 }  // namespace mirror
     47 
     48 class Monitor {
     49  public:
     50   // The default number of spins that are done before thread suspension is used to forcibly inflate
     51   // a lock word. See Runtime::max_spins_before_thin_lock_inflation_.
     52   constexpr static size_t kDefaultMaxSpinsBeforeThinLockInflation = 50;
     53 
     54   ~Monitor();
     55 
     56   static bool IsSensitiveThread();
     57   static void Init(uint32_t lock_profiling_threshold, bool (*is_sensitive_thread_hook)());
     58 
     59   // Return the thread id of the lock owner or 0 when there is no owner.
     60   static uint32_t GetLockOwnerThreadId(mirror::Object* obj)
     61       NO_THREAD_SAFETY_ANALYSIS;  // TODO: Reading lock owner without holding lock is racy.
     62 
     63   static mirror::Object* MonitorEnter(Thread* thread, mirror::Object* obj)
     64       EXCLUSIVE_LOCK_FUNCTION(obj)
     65       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     66   static bool MonitorExit(Thread* thread, mirror::Object* obj)
     67       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
     68       UNLOCK_FUNCTION(obj);
     69 
     70   static void Notify(Thread* self, mirror::Object* obj)
     71       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     72     DoNotify(self, obj, false);
     73   }
     74   static void NotifyAll(Thread* self, mirror::Object* obj)
     75       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     76     DoNotify(self, obj, true);
     77   }
     78   static void Wait(Thread* self, mirror::Object* obj, int64_t ms, int32_t ns,
     79                    bool interruptShouldThrow, ThreadState why)
     80       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     81 
     82   static void DescribeWait(std::ostream& os, const Thread* thread)
     83       LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
     84       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     85 
     86   // Used to implement JDWP's ThreadReference.CurrentContendedMonitor.
     87   static mirror::Object* GetContendedMonitor(Thread* thread)
     88       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     89 
     90   // Calls 'callback' once for each lock held in the single stack frame represented by
     91   // the current state of 'stack_visitor'.
     92   // The abort_on_failure flag allows to not die when the state of the runtime is unorderly. This
     93   // is necessary when we have already aborted but want to dump the stack as much as we can.
     94   static void VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
     95                          void* callback_context, bool abort_on_failure = true)
     96       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
     97 
     98   static bool IsValidLockWord(LockWord lock_word);
     99 
    100   template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
    101   mirror::Object* GetObject() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
    102     return obj_.Read<kReadBarrierOption>();
    103   }
    104 
    105   void SetObject(mirror::Object* object);
    106 
    107   Thread* GetOwner() const NO_THREAD_SAFETY_ANALYSIS {
    108     return owner_;
    109   }
    110 
    111   int32_t GetHashCode();
    112 
    113   bool IsLocked() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    114 
    115   bool HasHashCode() const {
    116     return hash_code_.LoadRelaxed() != 0;
    117   }
    118 
    119   MonitorId GetMonitorId() const {
    120     return monitor_id_;
    121   }
    122 
    123   // Inflate the lock on obj. May fail to inflate for spurious reasons, always re-check.
    124   static void InflateThinLocked(Thread* self, Handle<mirror::Object> obj, LockWord lock_word,
    125                                 uint32_t hash_code) NO_THREAD_SAFETY_ANALYSIS;
    126 
    127   static bool Deflate(Thread* self, mirror::Object* obj)
    128       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    129 
    130  private:
    131   explicit Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
    132         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    133   explicit Monitor(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code,
    134                    MonitorId id) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    135 
    136   // Install the monitor into its object, may fail if another thread installs a different monitor
    137   // first.
    138   bool Install(Thread* self)
    139       LOCKS_EXCLUDED(monitor_lock_)
    140       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    141 
    142   void AppendToWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
    143   void RemoveFromWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
    144 
    145   /*
    146    * Changes the shape of a monitor from thin to fat, preserving the internal lock state. The
    147    * calling thread must own the lock or the owner must be suspended. There's a race with other
    148    * threads inflating the lock, installing hash codes and spurious failures. The caller should
    149    * re-read the lock word following the call.
    150    */
    151   static void Inflate(Thread* self, Thread* owner, mirror::Object* obj, int32_t hash_code)
    152       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    153 
    154   void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
    155                           const char* owner_filename, uint32_t owner_line_number)
    156       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    157 
    158   static void FailedUnlock(mirror::Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
    159       LOCKS_EXCLUDED(Locks::thread_list_lock_)
    160       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    161 
    162   void Lock(Thread* self)
    163       LOCKS_EXCLUDED(monitor_lock_)
    164       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    165   bool Unlock(Thread* thread)
    166       LOCKS_EXCLUDED(monitor_lock_)
    167       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    168 
    169   static void DoNotify(Thread* self, mirror::Object* obj, bool notify_all)
    170       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    171 
    172   void Notify(Thread* self)
    173       LOCKS_EXCLUDED(monitor_lock_)
    174       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    175 
    176   void NotifyAll(Thread* self)
    177       LOCKS_EXCLUDED(monitor_lock_)
    178       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    179 
    180 
    181   void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow, ThreadState why)
    182       LOCKS_EXCLUDED(monitor_lock_)
    183       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    184 
    185   // Translates the provided method and pc into its declaring class' source file and line number.
    186   void TranslateLocation(mirror::ArtMethod* method, uint32_t pc,
    187                          const char** source_file, uint32_t* line_number) const
    188       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    189 
    190   uint32_t GetOwnerThreadId();
    191 
    192   static bool (*is_sensitive_thread_hook_)();
    193   static uint32_t lock_profiling_threshold_;
    194 
    195   Mutex monitor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
    196 
    197   ConditionVariable monitor_contenders_ GUARDED_BY(monitor_lock_);
    198 
    199   // Number of people waiting on the condition.
    200   size_t num_waiters_ GUARDED_BY(monitor_lock_);
    201 
    202   // Which thread currently owns the lock?
    203   Thread* volatile owner_ GUARDED_BY(monitor_lock_);
    204 
    205   // Owner's recursive lock depth.
    206   int lock_count_ GUARDED_BY(monitor_lock_);
    207 
    208   // What object are we part of. This is a weak root. Do not access
    209   // this directly, use GetObject() to read it so it will be guarded
    210   // by a read barrier.
    211   GcRoot<mirror::Object> obj_;
    212 
    213   // Threads currently waiting on this monitor.
    214   Thread* wait_set_ GUARDED_BY(monitor_lock_);
    215 
    216   // Stored object hash code, generated lazily by GetHashCode.
    217   AtomicInteger hash_code_;
    218 
    219   // Method and dex pc where the lock owner acquired the lock, used when lock
    220   // sampling is enabled. locking_method_ may be null if the lock is currently
    221   // unlocked, or if the lock is acquired by the system when the stack is empty.
    222   mirror::ArtMethod* locking_method_ GUARDED_BY(monitor_lock_);
    223   uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
    224 
    225   // The denser encoded version of this monitor as stored in the lock word.
    226   MonitorId monitor_id_;
    227 
    228 #ifdef __LP64__
    229   // Free list for monitor pool.
    230   Monitor* next_free_ GUARDED_BY(Locks::allocated_monitor_ids_lock_);
    231 #endif
    232 
    233   friend class MonitorInfo;
    234   friend class MonitorList;
    235   friend class MonitorPool;
    236   friend class mirror::Object;
    237   DISALLOW_COPY_AND_ASSIGN(Monitor);
    238 };
    239 
    240 class MonitorList {
    241  public:
    242   MonitorList();
    243   ~MonitorList();
    244 
    245   void Add(Monitor* m);
    246 
    247   void SweepMonitorList(IsMarkedCallback* callback, void* arg)
    248       LOCKS_EXCLUDED(monitor_list_lock_) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    249   void DisallowNewMonitors() LOCKS_EXCLUDED(monitor_list_lock_);
    250   void AllowNewMonitors() LOCKS_EXCLUDED(monitor_list_lock_);
    251   // Returns how many monitors were deflated.
    252   size_t DeflateMonitors() LOCKS_EXCLUDED(monitor_list_lock_)
    253       EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
    254 
    255   typedef std::list<Monitor*, TrackingAllocator<Monitor*, kAllocatorTagMonitorList>> Monitors;
    256 
    257  private:
    258   // During sweeping we may free an object and on a separate thread have an object created using
    259   // the newly freed memory. That object may then have its lock-word inflated and a monitor created.
    260   // If we allow new monitor registration during sweeping this monitor may be incorrectly freed as
    261   // the object wasn't marked when sweeping began.
    262   bool allow_new_monitors_ GUARDED_BY(monitor_list_lock_);
    263   Mutex monitor_list_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
    264   ConditionVariable monitor_add_condition_ GUARDED_BY(monitor_list_lock_);
    265   Monitors list_ GUARDED_BY(monitor_list_lock_);
    266 
    267   friend class Monitor;
    268   DISALLOW_COPY_AND_ASSIGN(MonitorList);
    269 };
    270 
    271 // Collects information about the current state of an object's monitor.
    272 // This is very unsafe, and must only be called when all threads are suspended.
    273 // For use only by the JDWP implementation.
    274 class MonitorInfo {
    275  public:
    276   explicit MonitorInfo(mirror::Object* o) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
    277 
    278   Thread* owner_;
    279   size_t entry_count_;
    280   std::vector<Thread*> waiters_;
    281 
    282  private:
    283   DISALLOW_COPY_AND_ASSIGN(MonitorInfo);
    284 };
    285 
    286 }  // namespace art
    287 
    288 #endif  // ART_RUNTIME_MONITOR_H_
    289