jdk8-mips64-public/hotspot: src/share/vm/runtime/mutexLocker.cpp@315a5d70b295

6484957: G1: parallel concurrent refinement
6826318: G1: remove traversal-based refinement code
Summary: Removed traversal-based refinement code as it's no longer used. Made the concurrent refinement (queue-based) parallel.
Reviewed-by: tonyp

     1 /*

     2  * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_mutexLocker.cpp.incl"

    28 // Mutexes used in the VM (see comment in mutexLocker.hpp):

    29 //

    30 // Note that the following pointers are effectively final -- after having been

    31 // set at JVM startup-time, they should never be subsequently mutated.

    32 // Instead of using pointers to malloc()ed monitors and mutexes we should consider

    33 // eliminating the indirection and using instances instead.

    34 // Consider using GCC's __read_mostly.

    36 Mutex*   Patching_lock                = NULL;

    37 Monitor* SystemDictionary_lock        = NULL;

    38 Mutex*   PackageTable_lock            = NULL;

    39 Mutex*   CompiledIC_lock              = NULL;

    40 Mutex*   InlineCacheBuffer_lock       = NULL;

    41 Mutex*   VMStatistic_lock             = NULL;

    42 Mutex*   JNIGlobalHandle_lock         = NULL;

    43 Mutex*   JNIHandleBlockFreeList_lock  = NULL;

    44 Mutex*   JNICachedItableIndex_lock    = NULL;

    45 Mutex*   JmethodIdCreation_lock       = NULL;

    46 Mutex*   JfieldIdCreation_lock        = NULL;

    47 Monitor* JNICritical_lock             = NULL;

    48 Mutex*   JvmtiThreadState_lock        = NULL;

    49 Monitor* JvmtiPendingEvent_lock       = NULL;

    50 Monitor* Heap_lock                    = NULL;

    51 Mutex*   ExpandHeap_lock              = NULL;

    52 Mutex*   AdapterHandlerLibrary_lock   = NULL;

    53 Mutex*   SignatureHandlerLibrary_lock = NULL;

    54 Mutex*   VtableStubs_lock             = NULL;

    55 Mutex*   SymbolTable_lock             = NULL;

    56 Mutex*   StringTable_lock             = NULL;

    57 Mutex*   CodeCache_lock               = NULL;

    58 Mutex*   MethodData_lock              = NULL;

    59 Mutex*   RetData_lock                 = NULL;

    60 Monitor* VMOperationQueue_lock        = NULL;

    61 Monitor* VMOperationRequest_lock      = NULL;

    62 Monitor* Safepoint_lock               = NULL;

    63 Monitor* SerializePage_lock           = NULL;

    64 Monitor* Threads_lock                 = NULL;

    65 Monitor* CGC_lock                     = NULL;

    66 Mutex*   STS_init_lock                = NULL;

    67 Monitor* SLT_lock                     = NULL;

    68 Monitor* iCMS_lock                    = NULL;

    69 Monitor* FullGCCount_lock             = NULL;

    70 Monitor* CMark_lock                   = NULL;

    71 Monitor* ZF_mon                       = NULL;

    72 Monitor* Cleanup_mon                  = NULL;

    73 Mutex*   SATB_Q_FL_lock               = NULL;

    74 Monitor* SATB_Q_CBL_mon               = NULL;

    75 Mutex*   Shared_SATB_Q_lock           = NULL;

    76 Mutex*   DirtyCardQ_FL_lock           = NULL;

    77 Monitor* DirtyCardQ_CBL_mon           = NULL;

    78 Mutex*   Shared_DirtyCardQ_lock       = NULL;

    79 Mutex*   ParGCRareEvent_lock          = NULL;

    80 Mutex*   EvacFailureStack_lock        = NULL;

    81 Mutex*   DerivedPointerTableGC_lock   = NULL;

    82 Mutex*   Compile_lock                 = NULL;

    83 Monitor* MethodCompileQueue_lock      = NULL;

    84 #ifdef TIERED

    85 Monitor* C1_lock                      = NULL;

    86 #endif // TIERED

    87 Monitor* CompileThread_lock           = NULL;

    88 Mutex*   CompileTaskAlloc_lock        = NULL;

    89 Mutex*   CompileStatistics_lock       = NULL;

    90 Mutex*   MultiArray_lock              = NULL;

    91 Monitor* Terminator_lock              = NULL;

    92 Monitor* BeforeExit_lock              = NULL;

    93 Monitor* Notify_lock                  = NULL;

    94 Monitor* Interrupt_lock               = NULL;

    95 Monitor* ProfileVM_lock               = NULL;

    96 Mutex*   ProfilePrint_lock            = NULL;

    97 Mutex*   ExceptionCache_lock          = NULL;

    98 Monitor* ObjAllocPost_lock            = NULL;

    99 Mutex*   OsrList_lock                 = NULL;

   100 #ifndef PRODUCT

   101 Mutex*   FullGCALot_lock              = NULL;

   102 #endif

   104 Mutex*   Debug1_lock                  = NULL;

   105 Mutex*   Debug2_lock                  = NULL;

   106 Mutex*   Debug3_lock                  = NULL;

   108 Mutex*   tty_lock                     = NULL;

   110 Mutex*   RawMonitor_lock              = NULL;

   111 Mutex*   PerfDataMemAlloc_lock        = NULL;

   112 Mutex*   PerfDataManager_lock         = NULL;

   113 Mutex*   OopMapCacheAlloc_lock        = NULL;

   115 Mutex*   MMUTracker_lock              = NULL;

   116 Mutex*   HotCardCache_lock            = NULL;

   118 Monitor* GCTaskManager_lock           = NULL;

   120 Mutex*   Management_lock              = NULL;

   121 Monitor* LowMemory_lock               = NULL;

   123 #define MAX_NUM_MUTEX 128

   124 static Monitor * _mutex_array[MAX_NUM_MUTEX];

   125 static int _num_mutex;

   127 #ifdef ASSERT

   128 void assert_locked_or_safepoint(const Monitor * lock) {

   129   // check if this thread owns the lock (common case)

   130   if (IgnoreLockingAssertions) return;

   131   assert(lock != NULL, "Need non-NULL lock");

   132   if (lock->owned_by_self()) return;

   133   if (SafepointSynchronize::is_at_safepoint()) return;

   134   if (!Universe::is_fully_initialized()) return;

   135   // see if invoker of VM operation owns it

   136   VM_Operation* op = VMThread::vm_operation();

   137   if (op != NULL && op->calling_thread() == lock->owner()) return;

   138   fatal1("must own lock %s", lock->name());

   139 }

   141 // a stronger assertion than the above

   142 void assert_lock_strong(const Monitor * lock) {

   143   if (IgnoreLockingAssertions) return;

   144   assert(lock != NULL, "Need non-NULL lock");

   145   if (lock->owned_by_self()) return;

   146   fatal1("must own lock %s", lock->name());

   147 }

   148 #endif

   150 #define def(var, type, pri, vm_block) {                           \

   151   var = new type(Mutex::pri, #var, vm_block);                     \

   152   assert(_num_mutex < MAX_NUM_MUTEX,                              \

   153                     "increase MAX_NUM_MUTEX");                    \

   154   _mutex_array[_num_mutex++] = var;                               \

   155 }

   157 void mutex_init() {

   158   def(tty_lock                     , Mutex  , event,       true ); // allow to lock in VM

   160   def(CGC_lock                   , Monitor, special,     true ); // coordinate between fore- and background GC

   161   def(STS_init_lock              , Mutex,   leaf,        true );

   162   if (UseConcMarkSweepGC) {

   163     def(iCMS_lock                  , Monitor, special,     true ); // CMS incremental mode start/stop notification

   164     def(FullGCCount_lock           , Monitor, leaf,        true ); // in support of ExplicitGCInvokesConcurrent

   165   }

   166   if (UseG1GC) {

   167     def(CMark_lock                 , Monitor, nonleaf,     true ); // coordinate concurrent mark thread

   168     def(ZF_mon                     , Monitor, leaf,        true );

   169     def(Cleanup_mon                , Monitor, nonleaf,     true );

   170     def(SATB_Q_FL_lock             , Mutex  , special,     true );

   171     def(SATB_Q_CBL_mon             , Monitor, nonleaf,     true );

   172     def(Shared_SATB_Q_lock         , Mutex,   nonleaf,     true );

   174     def(DirtyCardQ_FL_lock         , Mutex  , special,     true );

   175     def(DirtyCardQ_CBL_mon         , Monitor, nonleaf,     true );

   176     def(Shared_DirtyCardQ_lock     , Mutex,   nonleaf,     true );

   178     def(MMUTracker_lock            , Mutex  , leaf     ,   true );

   179     def(HotCardCache_lock          , Mutex  , special  ,   true );

   180     def(EvacFailureStack_lock      , Mutex  , nonleaf  ,   true );

   181   }

   182   def(ParGCRareEvent_lock          , Mutex  , leaf     ,   true );

   183   def(DerivedPointerTableGC_lock   , Mutex,   leaf,        true );

   184   def(CodeCache_lock               , Mutex  , special,     true );

   185   def(Interrupt_lock               , Monitor, special,     true ); // used for interrupt processing

   186   def(RawMonitor_lock              , Mutex,   special,     true );

   187   def(OopMapCacheAlloc_lock        , Mutex,   leaf,        true ); // used for oop_map_cache allocation.

   189   def(Patching_lock                , Mutex  , special,     true ); // used for safepointing and code patching.

   190   def(ObjAllocPost_lock            , Monitor, special,     false);

   191   def(LowMemory_lock               , Monitor, special,     true ); // used for low memory detection

   192   def(JmethodIdCreation_lock       , Mutex  , leaf,        true ); // used for creating jmethodIDs.

   194   def(SystemDictionary_lock        , Monitor, leaf,        true ); // lookups done by VM thread

   195   def(PackageTable_lock            , Mutex  , leaf,        false);

   196   def(InlineCacheBuffer_lock       , Mutex  , leaf,        true );

   197   def(VMStatistic_lock             , Mutex  , leaf,        false);

   198   def(ExpandHeap_lock              , Mutex  , leaf,        true ); // Used during compilation by VM thread

   199   def(JNIHandleBlockFreeList_lock  , Mutex  , leaf,        true ); // handles are used by VM thread

   200   def(SignatureHandlerLibrary_lock , Mutex  , leaf,        false);

   201   def(SymbolTable_lock             , Mutex  , leaf,        true );

   202   def(StringTable_lock             , Mutex  , leaf,        true );

   203   def(ProfilePrint_lock            , Mutex  , leaf,        false); // serial profile printing

   204   def(ExceptionCache_lock          , Mutex  , leaf,        false); // serial profile printing

   205   def(OsrList_lock                 , Mutex  , leaf,        true );

   206   def(Debug1_lock                  , Mutex  , leaf,        true );

   207 #ifndef PRODUCT

   208   def(FullGCALot_lock              , Mutex  , leaf,        false); // a lock to make FullGCALot MT safe

   209 #endif

   210   def(BeforeExit_lock              , Monitor, leaf,        true );

   211   def(PerfDataMemAlloc_lock        , Mutex  , leaf,        true ); // used for allocating PerfData memory for performance data

   212   def(PerfDataManager_lock         , Mutex  , leaf,        true ); // used for synchronized access to PerfDataManager resources

   214   // CMS_modUnionTable_lock                   leaf

   215   // CMS_bitMap_lock                          leaf + 1

   216   // CMS_freeList_lock                        leaf + 2

   218   def(Safepoint_lock               , Monitor, safepoint,   true ); // locks SnippetCache_lock/Threads_lock

   220   def(Threads_lock                 , Monitor, barrier,     true );

   222   def(VMOperationQueue_lock        , Monitor, nonleaf,     true ); // VM_thread allowed to block on these

   223   def(VMOperationRequest_lock      , Monitor, nonleaf,     true );

   224   def(RetData_lock                 , Mutex  , nonleaf,     false);

   225   def(Terminator_lock              , Monitor, nonleaf,     true );

   226   def(VtableStubs_lock             , Mutex  , nonleaf,     true );

   227   def(Notify_lock                  , Monitor, nonleaf,     true );

   228   def(JNIGlobalHandle_lock         , Mutex  , nonleaf,     true ); // locks JNIHandleBlockFreeList_lock

   229   def(JNICritical_lock             , Monitor, nonleaf,     true ); // used for JNI critical regions

   230   def(AdapterHandlerLibrary_lock   , Mutex  , nonleaf,     true);

   231   if (UseConcMarkSweepGC) {

   232     def(SLT_lock                   , Monitor, nonleaf,     false );

   233                     // used in CMS GC for locking PLL lock

   234   }

   235   def(Heap_lock                    , Monitor, nonleaf+1,   false);

   236   def(JfieldIdCreation_lock        , Mutex  , nonleaf+1,   true ); // jfieldID, Used in VM_Operation

   237   def(JNICachedItableIndex_lock    , Mutex  , nonleaf+1,   false); // Used to cache an itable index during JNI invoke

   239   def(CompiledIC_lock              , Mutex  , nonleaf+2,   false); // locks VtableStubs_lock, InlineCacheBuffer_lock

   240   def(CompileTaskAlloc_lock        , Mutex  , nonleaf+2,   true );

   241   def(CompileStatistics_lock       , Mutex  , nonleaf+2,   false);

   242   def(MultiArray_lock              , Mutex  , nonleaf+2,   false); // locks SymbolTable_lock

   244   def(JvmtiThreadState_lock        , Mutex  , nonleaf+2,   false); // Used by JvmtiThreadState/JvmtiEventController

   245   def(JvmtiPendingEvent_lock       , Monitor, nonleaf,     false); // Used by JvmtiCodeBlobEvents

   246   def(Management_lock              , Mutex  , nonleaf+2,   false); // used for JVM management

   248   def(Compile_lock                 , Mutex  , nonleaf+3,   true );

   249   def(MethodData_lock              , Mutex  , nonleaf+3,   false);

   251   def(MethodCompileQueue_lock      , Monitor, nonleaf+4,   true );

   252   def(Debug2_lock                  , Mutex  , nonleaf+4,   true );

   253   def(Debug3_lock                  , Mutex  , nonleaf+4,   true );

   254   def(ProfileVM_lock               , Monitor, nonleaf+4,   false); // used for profiling of the VMThread

   255   def(CompileThread_lock           , Monitor, nonleaf+5,   false );

   256 #ifdef TIERED

   257   def(C1_lock                      , Monitor, nonleaf+5,   false );

   258 #endif // TIERED

   261 }

   263 GCMutexLocker::GCMutexLocker(Monitor * mutex) {

   264   if (SafepointSynchronize::is_at_safepoint()) {

   265     _locked = false;

   266   } else {

   267     _mutex = mutex;

   268     _locked = true;

   269     _mutex->lock();

   270   }

   271 }

   273 // Print all mutexes/monitors that are currently owned by a thread; called

   274 // by fatal error handler.

   275 void print_owned_locks_on_error(outputStream* st) {

   276   st->print("VM Mutex/Monitor currently owned by a thread: ");

   277   bool none = true;

   278   for (int i = 0; i < _num_mutex; i++) {

   279      // see if it has an owner

   280      if (_mutex_array[i]->owner() != NULL) {

   281        if (none) {

   282           // print format used by Mutex::print_on_error()

   283           st->print_cr(" ([mutex/lock_event])");

   284           none = false;

   285        }

   286        _mutex_array[i]->print_on_error(st);

   287        st->cr();

   288      }

   289   }

   290   if (none) st->print_cr("None");

   291 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/runtime/mutexLocker.cpp@315a5d70b295

src/share/vm/runtime/mutexLocker.cpp