< prev index next >

src/share/vm/runtime/mutexLocker.hpp

Print this page
rev 8687 : 8004687: G1: Parallelize object self-forwarding and scanning during an evacuation failure
Summary: Use the regular task queue during evacuation failure and allow per-thread preserved header queues to remove the global lock during evacuation failure.
Reviewed-by:
Contributed-by: Walter Florian Gugenberger <walter.gugenberger@gmail.com>


  69 extern Monitor* FullGCCount_lock;                // in support of "concurrent" full gc
  70 extern Monitor* CMark_lock;                      // used for concurrent mark thread coordination
  71 extern Mutex*   CMRegionStack_lock;              // used for protecting accesses to the CM region stack
  72 extern Mutex*   SATB_Q_FL_lock;                  // Protects SATB Q
  73                                                  // buffer free list.
  74 extern Monitor* SATB_Q_CBL_mon;                  // Protects SATB Q
  75                                                  // completed buffer queue.
  76 extern Mutex*   Shared_SATB_Q_lock;              // Lock protecting SATB
  77                                                  // queue shared by
  78                                                  // non-Java threads.
  79 
  80 extern Mutex*   DirtyCardQ_FL_lock;              // Protects dirty card Q
  81                                                  // buffer free list.
  82 extern Monitor* DirtyCardQ_CBL_mon;              // Protects dirty card Q
  83                                                  // completed buffer queue.
  84 extern Mutex*   Shared_DirtyCardQ_lock;          // Lock protecting dirty card
  85                                                  // queue shared by
  86                                                  // non-Java threads.
  87                                                  // (see option ExplicitGCInvokesConcurrent)
  88 extern Mutex*   ParGCRareEvent_lock;             // Synchronizes various (rare) parallel GC ops.
  89 extern Mutex*   EvacFailureStack_lock;           // guards the evac failure scan stack
  90 extern Mutex*   Compile_lock;                    // a lock held when Compilation is updating code (used to block CodeCache traversal, CHA updates, etc)
  91 extern Monitor* MethodCompileQueue_lock;         // a lock held when method compilations are enqueued, dequeued
  92 extern Monitor* CompileThread_lock;              // a lock held by compile threads during compilation system initialization
  93 extern Monitor* Compilation_lock;                // a lock used to pause compilation
  94 extern Mutex*   CompileTaskAlloc_lock;           // a lock held when CompileTasks are allocated
  95 extern Mutex*   CompileStatistics_lock;          // a lock held when updating compilation statistics
  96 extern Mutex*   MultiArray_lock;                 // a lock used to guard allocation of multi-dim arrays
  97 extern Monitor* Terminator_lock;                 // a lock used to guard termination of the vm
  98 extern Monitor* BeforeExit_lock;                 // a lock used to guard cleanups and shutdown hooks
  99 extern Monitor* Notify_lock;                     // a lock used to synchronize the start-up of the vm
 100 extern Monitor* Interrupt_lock;                  // a lock used for condition variable mediated interrupt processing
 101 extern Monitor* ProfileVM_lock;                  // a lock used for profiling the VMThread
 102 extern Mutex*   ProfilePrint_lock;               // a lock used to serialize the printing of profiles
 103 extern Mutex*   ExceptionCache_lock;             // a lock used to synchronize exception cache updates
 104 extern Mutex*   OsrList_lock;                    // a lock used to serialize access to OSR queues
 105 extern Mutex*   ImageFileReaderTable_lock;       // a lock used to synchronize image readers open/close
 106 
 107 #ifndef PRODUCT
 108 extern Mutex*   FullGCALot_lock;                 // a lock to make FullGCALot MT safe
 109 #endif // PRODUCT




  69 extern Monitor* FullGCCount_lock;                // in support of "concurrent" full gc
  70 extern Monitor* CMark_lock;                      // used for concurrent mark thread coordination
  71 extern Mutex*   CMRegionStack_lock;              // used for protecting accesses to the CM region stack
  72 extern Mutex*   SATB_Q_FL_lock;                  // Protects SATB Q
  73                                                  // buffer free list.
  74 extern Monitor* SATB_Q_CBL_mon;                  // Protects SATB Q
  75                                                  // completed buffer queue.
  76 extern Mutex*   Shared_SATB_Q_lock;              // Lock protecting SATB
  77                                                  // queue shared by
  78                                                  // non-Java threads.
  79 
  80 extern Mutex*   DirtyCardQ_FL_lock;              // Protects dirty card Q
  81                                                  // buffer free list.
  82 extern Monitor* DirtyCardQ_CBL_mon;              // Protects dirty card Q
  83                                                  // completed buffer queue.
  84 extern Mutex*   Shared_DirtyCardQ_lock;          // Lock protecting dirty card
  85                                                  // queue shared by
  86                                                  // non-Java threads.
  87                                                  // (see option ExplicitGCInvokesConcurrent)
  88 extern Mutex*   ParGCRareEvent_lock;             // Synchronizes various (rare) parallel GC ops.

  89 extern Mutex*   Compile_lock;                    // a lock held when Compilation is updating code (used to block CodeCache traversal, CHA updates, etc)
  90 extern Monitor* MethodCompileQueue_lock;         // a lock held when method compilations are enqueued, dequeued
  91 extern Monitor* CompileThread_lock;              // a lock held by compile threads during compilation system initialization
  92 extern Monitor* Compilation_lock;                // a lock used to pause compilation
  93 extern Mutex*   CompileTaskAlloc_lock;           // a lock held when CompileTasks are allocated
  94 extern Mutex*   CompileStatistics_lock;          // a lock held when updating compilation statistics
  95 extern Mutex*   MultiArray_lock;                 // a lock used to guard allocation of multi-dim arrays
  96 extern Monitor* Terminator_lock;                 // a lock used to guard termination of the vm
  97 extern Monitor* BeforeExit_lock;                 // a lock used to guard cleanups and shutdown hooks
  98 extern Monitor* Notify_lock;                     // a lock used to synchronize the start-up of the vm
  99 extern Monitor* Interrupt_lock;                  // a lock used for condition variable mediated interrupt processing
 100 extern Monitor* ProfileVM_lock;                  // a lock used for profiling the VMThread
 101 extern Mutex*   ProfilePrint_lock;               // a lock used to serialize the printing of profiles
 102 extern Mutex*   ExceptionCache_lock;             // a lock used to synchronize exception cache updates
 103 extern Mutex*   OsrList_lock;                    // a lock used to serialize access to OSR queues
 104 extern Mutex*   ImageFileReaderTable_lock;       // a lock used to synchronize image readers open/close
 105 
 106 #ifndef PRODUCT
 107 extern Mutex*   FullGCALot_lock;                 // a lock to make FullGCALot MT safe
 108 #endif // PRODUCT


< prev index next >