< prev index next >


Print this page
rev 56635 : v2.00 -> v2.05 (CR5/v2.05/8-for-jdk13) patches combined into one; merge with 8229212.patch; merge with jdk-14+11; merge with 8230184.patch; merge with 8230876.patch; merge with jdk-14+15; merge with jdk-14+18.
rev 56637 : Add OM_CACHE_LINE_SIZE so that ObjectMonitor cache line sizes can be experimented with independently of DEFAULT_CACHE_LINE_SIZE; for SPARC and X64 configs that use 128 for DEFAULT_CACHE_LINE_SIZE, we are experimenting with 64; move _previous_owner_tid and _allocation_state fields to share the cache line with ObjectMonitor::_header; put ObjectMonitor::_ref_count on its own cache line after _owner; add 'int* count_p' parameter to deflate_monitor_list() and deflate_monitor_list_using_JT() and push counter updates down to where the ObjectMonitors are actually removed from the in-use lists; monitors_iterate() async deflation check should use negative ref_count; add 'JavaThread* target' param to deflate_per_thread_idle_monitors_using_JT() add deflate_common_idle_monitors_using_JT() to make it clear which JavaThread* is the target of the work and which is the calling JavaThread* (self); g_free_list, g_om_in_use_list and g_om_in_use_count are now static to synchronizer.cpp (reduce scope); add more diagnostic info to some assert()'s; minor code cleanups and code motion; save_om_ptr() should detect a race with a deflating thread that is bailing out and cause a retry when the ref_count field is not positive; merge with jdk-14+11; add special GC support for TestHumongousClassLoader.java; merge with 8230184.patch; merge with jdk-14+14; merge with jdk-14+18.
rev 56638 : Merge the remainder of the lock-free monitor list changes from v2.06 with v2.06a and v2.06b after running the changes through the edit scripts; merge pieces from dcubed.monitor_deflate_conc.v2.06d in dcubed.monitor_deflate_conc.v2.06[ac]; merge pieces from dcubed.monitor_deflate_conc.v2.06e into dcubed.monitor_deflate_conc.v2.06c; merge with jdk-14+11; test work around for test/jdk/tools/jlink/multireleasejar/JLinkMultiReleaseJarTest.java should not been needed anymore; merge with jdk-14+18.
rev 56639 : loosen a couple more counter checks due to races observed in testing; simplify om_release() extraction of mid since list head or cur_mid_in_use is marked; simplify deflate_monitor_list() extraction of mid since there are no parallel deleters due to the safepoint; simplify deflate_monitor_list_using_JT() extraction of mid since list head or cur_mid_in_use is marked; prepend_block_to_lists() - simplify based on David H's comments; does not need load_acquire() or release_store() because of the cmpxchg(); prepend_to_common() - simplify to use mark_next_loop() for m and use mark_list_head() and release_store() for the non-empty list case; add more debugging for "Non-balanced monitor enter/exit" failure mode; fix race in inflate() in the "CASE: neutral" code path; install_displaced_markword_in_object() does not need to clear the header field since that is handled when the ObjectMonitor is moved from the global free list; LSuccess should clear boxReg to set ICC.ZF=1 to avoid depending on existing boxReg contents; update fast_unlock() to detect when object no longer refers to the same ObjectMonitor and take fast path exit instead; clarify fast_lock() code where we detect when object no longer refers to the same ObjectMonitor; add/update comments for movptr() calls where we move a literal into an Address; remove set_owner(); refactor setting of owner field into set_owner_from(2 versions), set_owner_from_BasicLock(), and try_set_owner_from(); the new functions include monitorinflation+owner logging; extract debug code from v2.06 and v2.07 and move to v2.07.debug; change 'jccb' -> 'jcc' and 'jmpb' -> 'jmp' as needed; checkpoint initial version of MacroAssembler::inc_om_ref_count(); update LP64 MacroAssembler::fast_lock() and fast_unlock() to use inc_om_ref_count(); fast_lock() return flag setting logic can use 'testptr(tmpReg, tmpReg)' instead of 'cmpptr(tmpReg, 0)' since that's more efficient; fast_unlock() LSuccess return flag setting logic can use 'testl (boxReg, 0)' instead of 'xorptr(boxReg, boxReg)' since that's more efficient; cleanup "fast-path" vs "fast path" and "slow-path" vs "slow path"; update MacroAssembler::rtm_inflated_locking() to use inc_om_ref_count(); update MacroAssembler::fast_lock() to preserve the flags before decrementing ref_count and restore the flags afterwards; this is more clean than depending on the contents of rax/tmpReg; coleenp CR - refactor async monitor deflation work from ServiceThread::service_thread_entry() to ObjectSynchronizer::deflate_idle_monitors_using_JT(); rehn,eosterlund CR - add support for HandshakeAfterDeflateIdleMonitors for platforms that don't have ObjectMonitor ref_count support implemented in C2 fast_lock() and fast_unlock().

@@ -30,19 +30,26 @@
 #include "runtime/basicLock.hpp"
 #include "runtime/handles.hpp"
 #include "runtime/perfData.hpp"
 class ObjectMonitor;
+class ObjectMonitorHandle;
 class ThreadsList;
-typedef PaddedEnd<ObjectMonitor, DEFAULT_CACHE_LINE_SIZE> PaddedObjectMonitor;
+// Use DEFAULT_CACHE_LINE_SIZE if not already specified for
+// the current build platform.
+typedef PaddedEnd<ObjectMonitor, OM_CACHE_LINE_SIZE> PaddedObjectMonitor;
 struct DeflateMonitorCounters {
-  int n_in_use;              // currently associated with objects
-  int n_in_circulation;      // extant
-  int n_scavenged;           // reclaimed (global and per-thread)
-  int per_thread_scavenged;  // per-thread scavenge total
+  volatile int n_in_use;              // currently associated with objects
+  volatile int n_in_circulation;      // extant
+  volatile int n_scavenged;           // reclaimed (global and per-thread)
+  volatile int per_thread_scavenged;  // per-thread scavenge total
   double per_thread_times;   // per-thread scavenge times
 class ObjectSynchronizer : AllStatic {
   friend class VMStructs;

@@ -94,19 +101,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* om_alloc(Thread* self);
+  static ObjectMonitor* om_alloc(Thread* self, const InflateCause cause);
   static void om_release(Thread* self, ObjectMonitor* m,
                          bool FromPerThreadAlloc);
   static void om_flush(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);

@@ -124,64 +132,88 @@
   // 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_idle_monitors_using_JT();
+  static void deflate_global_idle_monitors_using_JT();
+  static void deflate_per_thread_idle_monitors_using_JT(JavaThread* target);
+  static void deflate_common_idle_monitors_using_JT(bool is_global, JavaThread* target);
   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** list_p,
+  static int deflate_monitor_list(ObjectMonitor* volatile * list_p,
+                                  int volatile * count_p,
                                   ObjectMonitor** free_head_p,
                                   ObjectMonitor** free_tail_p);
+  // 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* volatile * list_p,
+                                           int volatile * count_p,
+                                           ObjectMonitor** free_head_p,
+                                           ObjectMonitor** free_tail_p,
+                                           ObjectMonitor** saved_mid_in_use_p);
   static bool deflate_monitor(ObjectMonitor* mid, oop obj,
                               ObjectMonitor** free_head_p,
                               ObjectMonitor** free_tail_p);
-  static bool is_cleanup_needed();
+  static bool deflate_monitor_using_JT(ObjectMonitor* mid,
+                                       ObjectMonitor** free_head_p,
+                                       ObjectMonitor** free_tail_p);
+  static bool is_async_deflation_needed();
+  static bool is_safepoint_deflation_needed();
+  static bool is_async_deflation_requested() { return _is_async_deflation_requested; }
+  static bool is_special_deflation_requested() { return _is_special_deflation_requested; }
+  static void set_is_async_deflation_requested(bool new_value) { _is_async_deflation_requested = new_value; }
+  static void set_is_special_deflation_requested(bool new_value) { _is_special_deflation_requested = new_value; }
+  static jlong time_since_last_async_deflation_ms();
   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
   static void audit_and_print_stats(bool on_exit);
   static void chk_free_entry(JavaThread* jt, ObjectMonitor* n,
                              outputStream * out, int *error_cnt_p);
   static void chk_global_free_list_and_count(outputStream * out,
                                              int *error_cnt_p);
+  static void chk_global_wait_list_and_count(outputStream * out,
+                                             int *error_cnt_p);
   static void chk_global_in_use_list_and_count(outputStream * out,
                                                int *error_cnt_p);
   static void chk_in_use_entry(JavaThread* jt, ObjectMonitor* n,
                                outputStream * out, int *error_cnt_p);
   static void chk_per_thread_in_use_list_and_count(JavaThread *jt,
                                                    outputStream * out,
                                                    int *error_cnt_p);
   static void chk_per_thread_free_list_and_count(JavaThread *jt,
                                                  outputStream * out,
                                                  int *error_cnt_p);
-  static void log_in_use_monitor_details(outputStream * out, bool on_exit);
+  static void log_in_use_monitor_details(outputStream * out);
   static int  log_monitor_list_counts(outputStream * out);
   static int  verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0;
+  static void do_safepoint_work(DeflateMonitorCounters* counters);
   friend class SynchronizerTest;
   enum { _BLOCKSIZE = 128 };
   // global list of blocks of monitors
   static PaddedObjectMonitor* volatile g_block_list;
-  // global monitor free list
-  static ObjectMonitor* volatile g_free_list;
-  // global monitor in-use list, for moribund threads,
-  // monitors they inflated need to be scanned for deflation
-  static ObjectMonitor* volatile g_om_in_use_list;
-  // count of entries in g_om_in_use_list
-  static int g_om_in_use_count;
+  static volatile bool _is_async_deflation_requested;
+  static volatile bool _is_special_deflation_requested;
+  static jlong         _last_async_deflation_time_ns;
+  // Function to prepend new blocks to the appropriate lists:
+  static void prepend_block_to_lists(PaddedObjectMonitor* new_blk);
   // 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);
+  static void list_oops_do(ObjectMonitor* list, int count, OopClosure* f);
   // Support for SynchronizerTest access to GVars fields:
   static u_char* get_gvars_addr();
   static u_char* get_gvars_hc_sequence_addr();
   static size_t get_gvars_size();
< prev index next >