src/hotspot/share/runtime/synchronizer.hpp

rev 54612 : Checkpoint latest preliminary review patches for full OpenJDK review; merge with 8222295.patch.
rev 54613 : imported patch dcubed.monitor_deflate_conc.v2.01

@@ -30,10 +30,11 @@
 #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,19 +106,20 @@
   // 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 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 ObjectMonitor* inflate(Thread * Self, oop obj, const InflateCause cause);
+  static void inflate(ObjectMonitorHandle * omh_p, Thread * Self, oop obj,
+                      const InflateCause cause);
   // This version is only for internal use
-  static void inflate_helper(oop obj);
+  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,22 +137,36 @@
 
   // 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_common_idle_monitors_using_JT(bool is_global, JavaThread * self);
   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,10 +187,13 @@
                                                  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,10 +203,12 @@
   // 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);