src/hotspot/share/runtime/synchronizer.hpp

rev 54109 : Add logging to ObjectSynchronizer::omFlush(), add global count logging at Info level to ObjectSynchronizer::finish_deflate_idle_monitors(); for monitorinflation logging, switch from cumulative "deflating per-thread idle monitors" mesgs to per-thread "deflating per-thread idle monitors" mesgs; fix timer bug in deflate_thread_local_monitors() where time to acquire gListLock wasn't counted; fix misc typos.
rev 54110 : Checkpoint latest preliminary review patches for full OpenJDK review.

*** 30,39 ****
--- 30,40 ----
  #include "runtime/basicLock.hpp"
  #include "runtime/handles.hpp"
  #include "runtime/perfData.hpp"
  
  class ObjectMonitor;
+ class ObjectMonitorHandle;
  class ThreadsList;
  
  struct DeflateMonitorCounters {
    int nInuse;              // currently associated with objects
    int nInCirculation;      // extant
*** 105,123 ****
    // with original recursion count
    static intptr_t complete_exit(Handle obj, TRAPS);
    static void reenter (Handle obj, intptr_t recursion, TRAPS);
  
    // thread-specific and global objectMonitor free list accessors
!   static ObjectMonitor * omAlloc(Thread * Self);
    static void omRelease(Thread * Self, ObjectMonitor * m,
                          bool FromPerThreadAlloc);
    static void omFlush(Thread * Self);
  
    // Inflate light weight monitor to heavy weight monitor
!   static ObjectMonitor* inflate(Thread * Self, oop obj, const InflateCause cause);
    // This version is only for internal use
!   static void inflate_helper(oop obj);
    static const char* inflate_cause_name(const InflateCause cause);
  
    // Returns the identity hash value for an oop
    // NOTE: It may cause monitor inflation
    static intptr_t identity_hash_value_for(Handle obj);
--- 106,125 ----
    // with original recursion count
    static intptr_t complete_exit(Handle obj, TRAPS);
    static void reenter (Handle obj, intptr_t recursion, TRAPS);
  
    // thread-specific and global objectMonitor free list accessors
!   static ObjectMonitor * omAlloc(Thread * Self, const InflateCause cause);
    static void omRelease(Thread * Self, ObjectMonitor * m,
                          bool FromPerThreadAlloc);
    static void omFlush(Thread * Self);
  
    // Inflate light weight monitor to heavy weight monitor
!   static void inflate(ObjectMonitorHandle * omh_p, Thread * Self, oop obj,
!                       const InflateCause cause);
    // This version is only for internal use
!   static void inflate_helper(ObjectMonitorHandle * omh_p, oop obj);
    static const char* inflate_cause_name(const InflateCause cause);
  
    // Returns the identity hash value for an oop
    // NOTE: It may cause monitor inflation
    static intptr_t identity_hash_value_for(Handle obj);
*** 135,156 ****
--- 137,171 ----
  
    // GC: we current use aggressive monitor deflation policy
    // Basically we deflate all monitors that are not busy.
    // An adaptive profile-based deflation policy could be used if needed
    static void deflate_idle_monitors(DeflateMonitorCounters* counters);
+   static void deflate_global_idle_monitors_using_JT();
+   static void deflate_per_thread_idle_monitors_using_JT();
    static void deflate_thread_local_monitors(Thread* thread, DeflateMonitorCounters* counters);
    static void prepare_deflate_idle_monitors(DeflateMonitorCounters* counters);
    static void finish_deflate_idle_monitors(DeflateMonitorCounters* counters);
  
    // For a given monitor list: global or per-thread, deflate idle monitors
    static int deflate_monitor_list(ObjectMonitor** listheadp,
                                    ObjectMonitor** freeHeadp,
                                    ObjectMonitor** freeTailp);
+   // For a given in-use monitor list: global or per-thread, deflate idle
+   // monitors using a JavaThread.
+   static int deflate_monitor_list_using_JT(ObjectMonitor** listHeadp,
+                                            ObjectMonitor** freeHeadp,
+                                            ObjectMonitor** freeTailp,
+                                            ObjectMonitor** savedMidInUsep);
    static bool deflate_monitor(ObjectMonitor* mid, oop obj,
                                ObjectMonitor** freeHeadp,
                                ObjectMonitor** freeTailp);
+   static bool deflate_monitor_using_JT(ObjectMonitor* mid,
+                                        ObjectMonitor** freeHeadp,
+                                        ObjectMonitor** freeTailp);
    static bool is_cleanup_needed();
+   static bool is_cleanup_requested() { return _is_cleanup_requested; }
+   static void set_is_cleanup_requested(bool new_value) { _is_cleanup_requested = new_value; }
    static void oops_do(OopClosure* f);
    // Process oops in thread local used monitors
    static void thread_local_used_oops_do(Thread* thread, OopClosure* f);
  
    // debugging
*** 171,180 ****
--- 186,198 ----
                                                   int *error_cnt_p);
    static void log_in_use_monitor_details(outputStream * out, bool on_exit);
    static int  log_monitor_list_counts(outputStream * out);
    static int  verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0;
  
+   static bool gOmShouldDeflateIdleMonitors() { return _gOmShouldDeflateIdleMonitors; }
+   static void do_safepoint_work(DeflateMonitorCounters* _counters);
+ 
   private:
    friend class SynchronizerTest;
  
    enum { _BLOCKSIZE = 128 };
    // global list of blocks of monitors
*** 184,193 ****
--- 202,213 ----
    // global monitor in-use list, for moribund threads,
    // monitors they inflated need to be scanned for deflation
    static ObjectMonitor * volatile gOmInUseList;
    // count of entries in gOmInUseList
    static int gOmInUseCount;
+   static bool _gOmShouldDeflateIdleMonitors;
+   static volatile bool _is_cleanup_requested;
  
    // Process oops in all global used monitors (i.e. moribund thread's monitors)
    static void global_used_oops_do(OopClosure* f);
    // Process oops in monitors on the given list
    static void list_oops_do(ObjectMonitor* list, OopClosure* f);