hotspot/src/share/vm/runtime/synchronizer.cpp
author egahlin
Tue, 23 Aug 2016 19:21:48 +0200
changeset 40664 1ec65b303bb7
parent 40655 9f644073d3a0
child 46271 979ebd346ecf
permissions -rw-r--r--
8164523: Clean up metadata for event based tracing Reviewed-by: mlarsson, mgronlun
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 35934
diff changeset
     2
 * Copyright (c) 1998, 2016, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2526
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2526
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2526
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    26
#include "classfile/vmSymbols.hpp"
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
    27
#include "logging/log.hpp"
31345
1bba15125d8d 8015086: add interned strings to the shared archive.
jiangli
parents: 30244
diff changeset
    28
#include "memory/metaspaceShared.hpp"
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
    29
#include "memory/padded.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    30
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    31
#include "oops/markOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    32
#include "oops/oop.inline.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 37251
diff changeset
    33
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    34
#include "runtime/biasedLocking.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    35
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    36
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    37
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    38
#include "runtime/objectMonitor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    39
#include "runtime/objectMonitor.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    40
#include "runtime/osThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    41
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    42
#include "runtime/synchronizer.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14488
diff changeset
    43
#include "runtime/thread.inline.hpp"
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
    44
#include "runtime/vframe.hpp"
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
    45
#include "trace/traceMacros.hpp"
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
    46
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    47
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    48
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    49
#include "utilities/preserveException.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// The "core" versions of monitor enter and exit reside in this file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// The interpreter and compilers contain specialized transliterated
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// variants of the enter-exit fast-path operations.  See i486.ad fast_lock(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// for instance.  If you make changes here, make sure to modify the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// interpreter, and both C1 and C2 fast-path inline locking code emission.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// -----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
#ifdef DTRACE_ENABLED
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// Only bother with this argument setup if dtrace is available
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// TODO-FIXME: probes should not fire when caller is _blocked.  assert() accordingly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    64
#define DTRACE_MONITOR_PROBE_COMMON(obj, thread)                           \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  char* bytes = NULL;                                                      \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  int len = 0;                                                             \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  jlong jtid = SharedRuntime::get_java_tid(thread);                        \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    68
  Symbol* klassname = ((oop)(obj))->klass()->name();                       \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  if (klassname != NULL) {                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    bytes = (char*)klassname->bytes();                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    len = klassname->utf8_length();                                        \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    74
#define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis)            \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    75
  {                                                                        \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    76
    if (DTraceMonitorProbes) {                                             \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    77
      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    78
      HOTSPOT_MONITOR_WAIT(jtid,                                           \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    79
                           (uintptr_t)(monitor), bytes, len, (millis));    \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    80
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    81
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    82
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
    83
#define HOTSPOT_MONITOR_PROBE_notify HOTSPOT_MONITOR_NOTIFY
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
    84
#define HOTSPOT_MONITOR_PROBE_notifyAll HOTSPOT_MONITOR_NOTIFYALL
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 20282
diff changeset
    85
#define HOTSPOT_MONITOR_PROBE_waited HOTSPOT_MONITOR_WAITED
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    86
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    87
#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread)                  \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    88
  {                                                                        \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    89
    if (DTraceMonitorProbes) {                                             \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    90
      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    91
      HOTSPOT_MONITOR_PROBE_##probe(jtid, /* probe = waited */             \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    92
                                    (uintptr_t)(monitor), bytes, len);     \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    93
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    94
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    95
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
#else //  ndef DTRACE_ENABLED
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    98
#define DTRACE_MONITOR_WAIT_PROBE(obj, thread, millis, mon)    {;}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    99
#define DTRACE_MONITOR_PROBE(probe, obj, thread, mon)          {;}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
#endif // ndef DTRACE_ENABLED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   103
// This exists only as a workaround of dtrace bug 6254741
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   104
int dtrace_waited_probe(ObjectMonitor* monitor, Handle obj, Thread* thr) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   105
  DTRACE_MONITOR_PROBE(waited, monitor, obj(), thr);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   106
  return 0;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   107
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   108
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   109
#define NINFLATIONLOCKS 256
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   110
static volatile intptr_t gInflationLocks[NINFLATIONLOCKS];
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   111
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   112
// global list of blocks of monitors
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   113
// gBlockList is really PaddedEnd<ObjectMonitor> *, but we don't
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   114
// want to expose the PaddedEnd template more than necessary.
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   115
ObjectMonitor * volatile ObjectSynchronizer::gBlockList = NULL;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   116
// global monitor free list
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   117
ObjectMonitor * volatile ObjectSynchronizer::gFreeList  = NULL;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   118
// global monitor in-use list, for moribund threads,
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   119
// monitors they inflated need to be scanned for deflation
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   120
ObjectMonitor * volatile ObjectSynchronizer::gOmInUseList  = NULL;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   121
// count of entries in gOmInUseList
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   122
int ObjectSynchronizer::gOmInUseCount = 0;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   123
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   124
static volatile intptr_t gListLock = 0;      // protects global monitor lists
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   125
static volatile int gMonitorFreeCount  = 0;  // # on gFreeList
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   126
static volatile int gMonitorPopulation = 0;  // # Extant -- in circulation
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   127
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   128
static void post_monitor_inflate_event(EventJavaMonitorInflate&,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   129
                                       const oop,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   130
                                       const ObjectSynchronizer::InflateCause);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   131
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 18025
diff changeset
   132
#define CHAINMARKER (cast_to_oop<intptr_t>(-1))
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   133
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   134
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   135
// =====================> Quick functions
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   136
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   137
// The quick_* forms are special fast-path variants used to improve
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   138
// performance.  In the simplest case, a "quick_*" implementation could
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   139
// simply return false, in which case the caller will perform the necessary
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   140
// state transitions and call the slow-path form.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   141
// The fast-path is designed to handle frequently arising cases in an efficient
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   142
// manner and is just a degenerate "optimistic" variant of the slow-path.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   143
// returns true  -- to indicate the call was satisfied.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   144
// returns false -- to indicate the call needs the services of the slow-path.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   145
// A no-loitering ordinance is in effect for code in the quick_* family
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   146
// operators: safepoints or indefinite blocking (blocking that might span a
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   147
// safepoint) are forbidden. Generally the thread_state() is _in_Java upon
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   148
// entry.
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   149
//
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   150
// Consider: An interesting optimization is to have the JIT recognize the
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   151
// following common idiom:
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   152
//   synchronized (someobj) { .... ; notify(); }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   153
// That is, we find a notify() or notifyAll() call that immediately precedes
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   154
// the monitorexit operation.  In that case the JIT could fuse the operations
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   155
// into a single notifyAndExit() runtime primitive.
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   156
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   157
bool ObjectSynchronizer::quick_notify(oopDesc * obj, Thread * self, bool all) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   158
  assert(!SafepointSynchronize::is_at_safepoint(), "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   159
  assert(self->is_Java_thread(), "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   160
  assert(((JavaThread *) self)->thread_state() == _thread_in_Java, "invariant");
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35171
diff changeset
   161
  NoSafepointVerifier nsv;
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   162
  if (obj == NULL) return false;  // slow-path for invalid obj
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   163
  const markOop mark = obj->mark();
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   164
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   165
  if (mark->has_locker() && self->is_lock_owned((address)mark->locker())) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   166
    // Degenerate notify
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   167
    // stack-locked by caller so by definition the implied waitset is empty.
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   168
    return true;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   169
  }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   170
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   171
  if (mark->has_monitor()) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   172
    ObjectMonitor * const mon = mark->monitor();
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   173
    assert(mon->object() == obj, "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   174
    if (mon->owner() != self) return false;  // slow-path for IMS exception
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   175
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   176
    if (mon->first_waiter() != NULL) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   177
      // We have one or more waiters. Since this is an inflated monitor
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   178
      // that we own, we can transfer one or more threads from the waitset
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   179
      // to the entrylist here and now, avoiding the slow-path.
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   180
      if (all) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   181
        DTRACE_MONITOR_PROBE(notifyAll, mon, obj, self);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   182
      } else {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   183
        DTRACE_MONITOR_PROBE(notify, mon, obj, self);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   184
      }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   185
      int tally = 0;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   186
      do {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   187
        mon->INotify(self);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   188
        ++tally;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   189
      } while (mon->first_waiter() != NULL && all);
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   190
      OM_PERFDATA_OP(Notifications, inc(tally));
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   191
    }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   192
    return true;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   193
  }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   194
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   195
  // biased locking and any other IMS exception states take the slow-path
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   196
  return false;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   197
}
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   198
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   199
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   200
// The LockNode emitted directly at the synchronization site would have
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   201
// been too big if it were to have included support for the cases of inflated
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   202
// recursive enter and exit, so they go here instead.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   203
// Note that we can't safely call AsyncPrintJavaStack() from within
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   204
// quick_enter() as our thread state remains _in_Java.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   205
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   206
bool ObjectSynchronizer::quick_enter(oop obj, Thread * Self,
37250
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   207
                                     BasicLock * lock) {
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   208
  assert(!SafepointSynchronize::is_at_safepoint(), "invariant");
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   209
  assert(Self->is_Java_thread(), "invariant");
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   210
  assert(((JavaThread *) Self)->thread_state() == _thread_in_Java, "invariant");
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35171
diff changeset
   211
  NoSafepointVerifier nsv;
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   212
  if (obj == NULL) return false;       // Need to throw NPE
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   213
  const markOop mark = obj->mark();
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   214
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   215
  if (mark->has_monitor()) {
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   216
    ObjectMonitor * const m = mark->monitor();
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   217
    assert(m->object() == obj, "invariant");
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   218
    Thread * const owner = (Thread *) m->_owner;
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   219
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   220
    // Lock contention and Transactional Lock Elision (TLE) diagnostics
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   221
    // and observability
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   222
    // Case: light contention possibly amenable to TLE
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   223
    // Case: TLE inimical operations such as nested/recursive synchronization
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   224
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   225
    if (owner == Self) {
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   226
      m->_recursions++;
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   227
      return true;
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   228
    }
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   229
37250
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   230
    // This Java Monitor is inflated so obj's header will never be
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   231
    // displaced to this thread's BasicLock. Make the displaced header
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   232
    // non-NULL so this BasicLock is not seen as recursive nor as
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   233
    // being locked. We do this unconditionally so that this thread's
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   234
    // BasicLock cannot be mis-interpreted by any stack walkers. For
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   235
    // performance reasons, stack walkers generally first check for
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   236
    // Biased Locking in the object's header, the second check is for
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   237
    // stack-locking in the object's header, the third check is for
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   238
    // recursive stack-locking in the displaced header in the BasicLock,
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   239
    // and last are the inflated Java Monitor (ObjectMonitor) checks.
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   240
    lock->set_displaced_header(markOopDesc::unused_mark());
2fecd8bdc8e9 8077392: Stream fork/join tasks occasionally fail to complete
dcubed
parents: 37092
diff changeset
   241
29070
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   242
    if (owner == NULL &&
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   243
        Atomic::cmpxchg_ptr(Self, &(m->_owner), NULL) == NULL) {
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   244
      assert(m->_recursions == 0, "invariant");
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   245
      assert(m->_owner == Self, "invariant");
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   246
      return true;
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   247
    }
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   248
  }
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   249
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   250
  // Note that we could inflate in quick_enter.
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   251
  // This is likely a useful optimization
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   252
  // Critically, in quick_enter() we must not:
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   253
  // -- perform bias revocation, or
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   254
  // -- block indefinitely, or
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   255
  // -- reach a safepoint
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   256
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   257
  return false;        // revert to slow-path
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   258
}
b0a5fc9c59c8 8061553: Contended Locking fast enter bucket
dcubed
parents: 28621
diff changeset
   259
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   260
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   261
//  Fast Monitor Enter/Exit
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   262
// This the fast monitor enter. The interpreter and compiler use
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   263
// some assembly copies of this code. Make sure update those code
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   264
// if the following function is changed. The implementation is
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   265
// extremely sensitive to race condition. Be careful.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   266
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   267
void ObjectSynchronizer::fast_enter(Handle obj, BasicLock* lock,
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   268
                                    bool attempt_rebias, TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   269
  if (UseBiasedLocking) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   270
    if (!SafepointSynchronize::is_at_safepoint()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   271
      BiasedLocking::Condition cond = BiasedLocking::revoke_and_rebias(obj, attempt_rebias, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   272
      if (cond == BiasedLocking::BIAS_REVOKED_AND_REBIASED) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   273
        return;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   274
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   275
    } else {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   276
      assert(!attempt_rebias, "can not rebias toward VM thread");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   277
      BiasedLocking::revoke_at_safepoint(obj);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   278
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   279
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   280
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   281
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   282
  slow_enter(obj, lock, THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   283
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   284
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   285
void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   286
  markOop mark = object->mark();
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   287
  // We cannot check for Biased Locking if we are racing an inflation.
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   288
  assert(mark == markOopDesc::INFLATING() ||
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   289
         !mark->has_bias_pattern(), "should not see bias pattern here");
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   290
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   291
  markOop dhw = lock->displaced_header();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   292
  if (dhw == NULL) {
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   293
    // If the displaced header is NULL, then this exit matches up with
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   294
    // a recursive enter. No real work to do here except for diagnostics.
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   295
#ifndef PRODUCT
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   296
    if (mark != markOopDesc::INFLATING()) {
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   297
      // Only do diagnostics if we are not racing an inflation. Simply
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   298
      // exiting a recursive enter of a Java Monitor that is being
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   299
      // inflated is safe; see the has_monitor() comment below.
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   300
      assert(!mark->is_neutral(), "invariant");
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   301
      assert(!mark->has_locker() ||
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   302
             THREAD->is_lock_owned((address)mark->locker()), "invariant");
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   303
      if (mark->has_monitor()) {
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   304
        // The BasicLock's displaced_header is marked as a recursive
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   305
        // enter and we have an inflated Java Monitor (ObjectMonitor).
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   306
        // This is a special case where the Java Monitor was inflated
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   307
        // after this thread entered the stack-lock recursively. When a
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   308
        // Java Monitor is inflated, we cannot safely walk the Java
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   309
        // Monitor owner's stack and update the BasicLocks because a
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   310
        // Java Monitor can be asynchronously inflated by a thread that
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   311
        // does not own the Java Monitor.
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   312
        ObjectMonitor * m = mark->monitor();
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   313
        assert(((oop)(m->object()))->mark() == mark, "invariant");
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   314
        assert(m->is_entered(THREAD), "invariant");
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   315
      }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   316
    }
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   317
#endif
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   318
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   319
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   320
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   321
  if (mark == (markOop) lock) {
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   322
    // If the object is stack-locked by the current thread, try to
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   323
    // swing the displaced header from the BasicLock back to the mark.
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   324
    assert(dhw->is_neutral(), "invariant");
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   325
    if ((markOop) Atomic::cmpxchg_ptr(dhw, object->mark_addr(), mark) == mark) {
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   326
      TEVENT(fast_exit: release stack-lock);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   327
      return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   328
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   329
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   330
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
   331
  // We have to take the slow-path of possible inflation and then exit.
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   332
  ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   333
                              object,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   334
                              inflate_cause_vm_internal)->exit(true, THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   335
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   336
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   337
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   338
// Interpreter/Compiler Slow Case
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   339
// This routine is used to handle interpreter/compiler slow case
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   340
// We don't need to use fast path here, because it must have been
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   341
// failed in the interpreter/compiler code.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   342
void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   343
  markOop mark = obj->mark();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   344
  assert(!mark->has_bias_pattern(), "should not see bias pattern here");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   345
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   346
  if (mark->is_neutral()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   347
    // Anticipate successful CAS -- the ST of the displaced mark must
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   348
    // be visible <= the ST performed by the CAS.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   349
    lock->set_displaced_header(mark);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   350
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   351
      TEVENT(slow_enter: release stacklock);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   352
      return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   353
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   354
    // Fall through to inflate() ...
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   355
  } else if (mark->has_locker() &&
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   356
             THREAD->is_lock_owned((address)mark->locker())) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   357
    assert(lock != mark->locker(), "must not re-lock the same lock");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   358
    assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   359
    lock->set_displaced_header(NULL);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   360
    return;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   361
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   362
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   363
  // The object header will never be displaced to this lock,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   364
  // so it does not matter what the value is, except that it
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   365
  // must be non-zero to avoid looking like a re-entrant lock,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   366
  // and must not look locked either.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   367
  lock->set_displaced_header(markOopDesc::unused_mark());
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   368
  ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   369
                              obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   370
                              inflate_cause_monitor_enter)->enter(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   371
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   372
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   373
// This routine is used to handle interpreter/compiler slow case
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   374
// We don't need to use fast path here, because it must have
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   375
// failed in the interpreter/compiler code. Simply use the heavy
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   376
// weight monitor should be ok, unless someone find otherwise.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   377
void ObjectSynchronizer::slow_exit(oop object, BasicLock* lock, TRAPS) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   378
  fast_exit(object, lock, THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   379
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   380
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   381
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   382
// Class Loader  support to workaround deadlocks on the class loader lock objects
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   383
// Also used by GC
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   384
// complete_exit()/reenter() are used to wait on a nested lock
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   385
// i.e. to give up an outer lock completely and then re-enter
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   386
// Used when holding nested locks - lock acquisition order: lock1 then lock2
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   387
//  1) complete_exit lock1 - saving recursion count
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   388
//  2) wait on lock2
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   389
//  3) when notified on lock2, unlock lock2
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   390
//  4) reenter lock1 with original recursion count
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   391
//  5) lock lock2
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   392
// NOTE: must use heavy weight monitor to handle complete_exit/reenter()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   393
intptr_t ObjectSynchronizer::complete_exit(Handle obj, TRAPS) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   394
  TEVENT(complete_exit);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   395
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   396
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   397
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   400
  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   401
                                                       obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   402
                                                       inflate_cause_vm_internal);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   403
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   404
  return monitor->complete_exit(THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   405
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   406
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   407
// NOTE: must use heavy weight monitor to handle complete_exit/reenter()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   408
void ObjectSynchronizer::reenter(Handle obj, intptr_t recursion, TRAPS) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   409
  TEVENT(reenter);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   410
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   411
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   412
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   413
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   414
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   415
  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   416
                                                       obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   417
                                                       inflate_cause_vm_internal);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   418
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   419
  monitor->reenter(recursion, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   420
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   421
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   422
// JNI locks on java objects
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   423
// NOTE: must use heavy weight monitor to handle jni monitor enter
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   424
void ObjectSynchronizer::jni_enter(Handle obj, TRAPS) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   425
  // the current locking is from JNI instead of Java code
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   426
  TEVENT(jni_enter);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   427
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   428
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   429
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   430
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   431
  THREAD->set_current_pending_monitor_is_from_java(false);
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   432
  ObjectSynchronizer::inflate(THREAD, obj(), inflate_cause_jni_enter)->enter(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   433
  THREAD->set_current_pending_monitor_is_from_java(true);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   434
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   435
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   436
// NOTE: must use heavy weight monitor to handle jni monitor exit
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   437
void ObjectSynchronizer::jni_exit(oop obj, Thread* THREAD) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   438
  TEVENT(jni_exit);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   439
  if (UseBiasedLocking) {
15233
c06b129cf6c7 6444286: Possible naked oop related to biased locking revocation safepoint in jni_exit()
dcubed
parents: 14583
diff changeset
   440
    Handle h_obj(THREAD, obj);
c06b129cf6c7 6444286: Possible naked oop related to biased locking revocation safepoint in jni_exit()
dcubed
parents: 14583
diff changeset
   441
    BiasedLocking::revoke_and_rebias(h_obj, false, THREAD);
c06b129cf6c7 6444286: Possible naked oop related to biased locking revocation safepoint in jni_exit()
dcubed
parents: 14583
diff changeset
   442
    obj = h_obj();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   443
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   444
  assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   445
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   446
  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   447
                                                       obj,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   448
                                                       inflate_cause_jni_exit);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   449
  // If this thread has locked the object, exit the monitor.  Note:  can't use
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   450
  // monitor->check(CHECK); must exit even if an exception is pending.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   451
  if (monitor->check(THREAD)) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   452
    monitor->exit(true, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   454
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   455
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   456
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   457
// Internal VM locks on java objects
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   458
// standard constructor, allows locking failures
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   459
ObjectLocker::ObjectLocker(Handle obj, Thread* thread, bool doLock) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   460
  _dolock = doLock;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   461
  _thread = thread;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   462
  debug_only(if (StrictSafepointChecks) _thread->check_for_valid_safepoint_state(false);)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   463
  _obj = obj;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   465
  if (_dolock) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   466
    TEVENT(ObjectLocker);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   467
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   468
    ObjectSynchronizer::fast_enter(_obj, &_lock, false, _thread);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   469
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   470
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   471
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   472
ObjectLocker::~ObjectLocker() {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   473
  if (_dolock) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   474
    ObjectSynchronizer::fast_exit(_obj(), &_lock, _thread);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   475
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   476
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   479
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   480
//  Wait/Notify/NotifyAll
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   481
// NOTE: must use heavy weight monitor to handle wait()
22743
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   482
int ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   483
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   484
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   485
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   486
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   487
  if (millis < 0) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   488
    TEVENT(wait - throw IAX);
22743
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   489
    THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   490
  }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   491
  ObjectMonitor* monitor = ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   492
                                                       obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   493
                                                       inflate_cause_wait);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   494
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   495
  DTRACE_MONITOR_WAIT_PROBE(monitor, obj(), THREAD, millis);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   496
  monitor->wait(millis, true, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   497
22743
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   498
  // This dummy call is in place to get around dtrace bug 6254741.  Once
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   499
  // that's fixed we can uncomment the following line, remove the call
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   500
  // and change this function back into a "void" func.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   501
  // DTRACE_MONITOR_PROBE(waited, monitor, obj(), THREAD);
22743
e043208c9d93 8030808: dtrace/hotspot/Monitors/Monitors001 fails in product builds on solaris-sparc
fparain
parents: 22551
diff changeset
   502
  return dtrace_waited_probe(monitor, obj, THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   503
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   505
void ObjectSynchronizer::waitUninterruptibly(Handle obj, jlong millis, TRAPS) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   506
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   507
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   508
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   509
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   510
  if (millis < 0) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   511
    TEVENT(wait - throw IAX);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   512
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   513
  }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   514
  ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   515
                              obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   516
                              inflate_cause_wait)->wait(millis, false, THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   517
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   518
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   519
void ObjectSynchronizer::notify(Handle obj, TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   520
  if (UseBiasedLocking) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   521
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   522
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   523
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   525
  markOop mark = obj->mark();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   526
  if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   527
    return;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   528
  }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   529
  ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   530
                              obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   531
                              inflate_cause_notify)->notify(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   532
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   534
// NOTE: see comment of notify()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   535
void ObjectSynchronizer::notifyall(Handle obj, TRAPS) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   536
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   537
    BiasedLocking::revoke_and_rebias(obj, false, THREAD);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   538
    assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   539
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   540
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   541
  markOop mark = obj->mark();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   542
  if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   543
    return;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   544
  }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   545
  ObjectSynchronizer::inflate(THREAD,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   546
                              obj(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   547
                              inflate_cause_notify)->notifyAll(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   548
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   549
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   550
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   551
// Hash Code handling
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   552
//
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
// Performance concern:
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   554
// OrderAccess::storestore() calls release() which at one time stored 0
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   555
// into the global volatile OrderAccess::dummy variable. This store was
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   556
// unnecessary for correctness. Many threads storing into a common location
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   557
// causes considerable cache migration or "sloshing" on large SMP systems.
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   558
// As such, I avoided using OrderAccess::storestore(). In some cases
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   559
// OrderAccess::fence() -- which incurs local latency on the executing
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   560
// processor -- is a better choice as it scales on SMP systems.
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   561
//
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   562
// See http://blogs.oracle.com/dave/entry/biased_locking_in_hotspot for
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   563
// a discussion of coherency costs. Note that all our current reference
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   564
// platforms provide strong ST-ST order, so the issue is moot on IA32,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   565
// x64, and SPARC.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
// As a general policy we use "volatile" to control compiler-based reordering
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   568
// and explicit fences (barriers) to control for architectural reordering
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
   569
// performed by the CPU(s) or platform.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
struct SharedGlobals {
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   572
  char         _pad_prefix[DEFAULT_CACHE_LINE_SIZE];
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   573
  // These are highly shared mostly-read variables.
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   574
  // To avoid false-sharing they need to be the sole occupants of a cache line.
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   575
  volatile int stwRandom;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   576
  volatile int stwCycle;
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   577
  DEFINE_PAD_MINUS_SIZE(1, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile int) * 2);
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   578
  // Hot RW variable -- Sequester to avoid false-sharing
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   579
  volatile int hcSequence;
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   580
  DEFINE_PAD_MINUS_SIZE(2, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile int));
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   581
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   583
static SharedGlobals GVars;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   584
static int MonitorScavengeThreshold = 1000000;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   585
static volatile int ForceMonitorScavenge = 0; // Scavenge required and pending
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   587
static markOop ReadStableMark(oop obj) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   588
  markOop mark = obj->mark();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   589
  if (!mark->is_being_inflated()) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   590
    return mark;       // normal fast-path return
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   591
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   593
  int its = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   594
  for (;;) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   595
    markOop mark = obj->mark();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   596
    if (!mark->is_being_inflated()) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   597
      return mark;    // normal fast-path return
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   598
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   599
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   600
    // The object is being inflated by some other thread.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   601
    // The caller of ReadStableMark() must wait for inflation to complete.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   602
    // Avoid live-lock
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   603
    // TODO: consider calling SafepointSynchronize::do_call_back() while
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   604
    // spinning to see if there's a safepoint pending.  If so, immediately
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   605
    // yielding or blocking would be appropriate.  Avoid spinning while
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   606
    // there is a safepoint pending.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   607
    // TODO: add inflation contention performance counters.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   608
    // TODO: restrict the aggregate number of spinners.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   610
    ++its;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   611
    if (its > 10000 || !os::is_MP()) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   612
      if (its & 1) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   613
        os::naked_yield();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   614
        TEVENT(Inflate: INFLATING - yield);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   615
      } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   616
        // Note that the following code attenuates the livelock problem but is not
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   617
        // a complete remedy.  A more complete solution would require that the inflating
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   618
        // thread hold the associated inflation lock.  The following code simply restricts
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   619
        // the number of spinners to at most one.  We'll have N-2 threads blocked
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   620
        // on the inflationlock, 1 thread holding the inflation lock and using
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   621
        // a yield/park strategy, and 1 thread in the midst of inflation.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   622
        // A more refined approach would be to change the encoding of INFLATING
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   623
        // to allow encapsulation of a native thread pointer.  Threads waiting for
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   624
        // inflation to complete would use CAS to push themselves onto a singly linked
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   625
        // list rooted at the markword.  Once enqueued, they'd loop, checking a per-thread flag
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   626
        // and calling park().  When inflation was complete the thread that accomplished inflation
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   627
        // would detach the list and set the markword to inflated with a single CAS and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   628
        // then for each thread on the list, set the flag and unpark() the thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   629
        // This is conceptually similar to muxAcquire-muxRelease, except that muxRelease
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   630
        // wakes at most one thread whereas we need to wake the entire list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   631
        int ix = (cast_from_oop<intptr_t>(obj) >> 5) & (NINFLATIONLOCKS-1);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   632
        int YieldThenBlock = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   633
        assert(ix >= 0 && ix < NINFLATIONLOCKS, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   634
        assert((NINFLATIONLOCKS & (NINFLATIONLOCKS-1)) == 0, "invariant");
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   635
        Thread::muxAcquire(gInflationLocks + ix, "gInflationLock");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   636
        while (obj->mark() == markOopDesc::INFLATING()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   637
          // Beware: NakedYield() is advisory and has almost no effect on some platforms
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   638
          // so we periodically call Self->_ParkEvent->park(1).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   639
          // We use a mixed spin/yield/block mechanism.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   640
          if ((YieldThenBlock++) >= 16) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   641
            Thread::current()->_ParkEvent->park(1);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   642
          } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   643
            os::naked_yield();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   644
          }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   645
        }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   646
        Thread::muxRelease(gInflationLocks + ix);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   647
        TEVENT(Inflate: INFLATING - yield/park);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   648
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   649
    } else {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   650
      SpinPause();       // SMP-polite spinning
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   651
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   652
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   653
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// hashCode() generation :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
// Possibilities:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
// * MD5Digest of {obj,stwRandom}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
// * CRC32 of {obj,stwRandom} or any linear-feedback shift register function.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
// * A DES- or AES-style SBox[] mechanism
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
// * One of the Phi-based schemes, such as:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
//   2654435761 = 2^32 * Phi (golden ratio)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
//   HashCodeValue = ((uintptr_t(obj) >> 3) * 2654435761) ^ GVars.stwRandom ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// * A variation of Marsaglia's shift-xor RNG scheme.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
// * (obj ^ stwRandom) is appealing, but can result
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
//   in undesirable regularity in the hashCode values of adjacent objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
//   (objects allocated back-to-back, in particular).  This could potentially
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
//   result in hashtable collisions and reduced hashtable efficiency.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
//   There are simple ways to "diffuse" the middle address bits over the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
//   generated hashCode values:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
static inline intptr_t get_next_hash(Thread * Self, oop obj) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   673
  intptr_t value = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  if (hashCode == 0) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   675
    // This form uses an unguarded global Park-Miller RNG,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   676
    // so it's possible for two threads to race and generate the same RNG.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   677
    // On MP system we'll have lots of RW access to a global, so the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   678
    // mechanism induces lots of coherency traffic.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   679
    value = os::random();
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   680
  } else if (hashCode == 1) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   681
    // This variation has the property of being stable (idempotent)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   682
    // between STW operations.  This can be useful in some of the 1-0
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   683
    // synchronization schemes.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   684
    intptr_t addrBits = cast_from_oop<intptr_t>(obj) >> 3;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   685
    value = addrBits ^ (addrBits >> 5) ^ GVars.stwRandom;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   686
  } else if (hashCode == 2) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   687
    value = 1;            // for sensitivity testing
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   688
  } else if (hashCode == 3) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   689
    value = ++GVars.hcSequence;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   690
  } else if (hashCode == 4) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   691
    value = cast_from_oop<intptr_t>(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  } else {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   693
    // Marsaglia's xor-shift scheme with thread-specific state
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   694
    // This is probably the best overall implementation -- we'll
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   695
    // likely make this the default in future releases.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   696
    unsigned t = Self->_hashStateX;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   697
    t ^= (t << 11);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   698
    Self->_hashStateX = Self->_hashStateY;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   699
    Self->_hashStateY = Self->_hashStateZ;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   700
    Self->_hashStateZ = Self->_hashStateW;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   701
    unsigned v = Self->_hashStateW;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   702
    v = (v ^ (v >> 19)) ^ (t ^ (t >> 8));
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   703
    Self->_hashStateW = v;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   704
    value = v;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  value &= markOopDesc::hash_mask;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   708
  if (value == 0) value = 0xBAD;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   709
  assert(value != markOopDesc::no_hash, "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   710
  TEVENT(hashCode: GENERATE);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  return value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
}
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   713
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   714
intptr_t ObjectSynchronizer::FastHashCode(Thread * Self, oop obj) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   715
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   716
    // NOTE: many places throughout the JVM do not expect a safepoint
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   717
    // to be taken here, in particular most operations on perm gen
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   718
    // objects. However, we only ever bias Java instances and all of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   719
    // the call sites of identity_hash that might revoke biases have
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   720
    // been checked to make sure they can handle a safepoint. The
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   721
    // added check of the bias pattern is to avoid useless calls to
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   722
    // thread-local storage.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   723
    if (obj->mark()->has_bias_pattern()) {
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   724
      // Handle for oop obj in case of STW safepoint
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   725
      Handle hobj(Self, obj);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   726
      // Relaxing assertion for bug 6320749.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   727
      assert(Universe::verify_in_progress() ||
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   728
             !SafepointSynchronize::is_at_safepoint(),
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   729
             "biases should not be seen by VM thread here");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   730
      BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   731
      obj = hobj();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   732
      assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   733
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   734
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   736
  // hashCode() is a heap mutator ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   737
  // Relaxing assertion for bug 6320749.
31345
1bba15125d8d 8015086: add interned strings to the shared archive.
jiangli
parents: 30244
diff changeset
   738
  assert(Universe::verify_in_progress() || DumpSharedSpaces ||
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   739
         !SafepointSynchronize::is_at_safepoint(), "invariant");
31345
1bba15125d8d 8015086: add interned strings to the shared archive.
jiangli
parents: 30244
diff changeset
   740
  assert(Universe::verify_in_progress() || DumpSharedSpaces ||
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   741
         Self->is_Java_thread() , "invariant");
31345
1bba15125d8d 8015086: add interned strings to the shared archive.
jiangli
parents: 30244
diff changeset
   742
  assert(Universe::verify_in_progress() || DumpSharedSpaces ||
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   743
         ((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   744
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   745
  ObjectMonitor* monitor = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   746
  markOop temp, test;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   747
  intptr_t hash;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   748
  markOop mark = ReadStableMark(obj);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   749
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   750
  // object should remain ineligible for biased locking
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   751
  assert(!mark->has_bias_pattern(), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   752
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   753
  if (mark->is_neutral()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   754
    hash = mark->hash();              // this is a normal header
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   755
    if (hash) {                       // if it has hash, just return it
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   756
      return hash;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   757
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   758
    hash = get_next_hash(Self, obj);  // allocate a new hash code
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   759
    temp = mark->copy_set_hash(hash); // merge the hash code into header
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   760
    // use (machine word version) atomic operation to install the hash
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   761
    test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   762
    if (test == mark) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   763
      return hash;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   764
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   765
    // If atomic operation failed, we must inflate the header
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   766
    // into heavy weight monitor. We could add more code here
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   767
    // for fast path, but it does not worth the complexity.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   768
  } else if (mark->has_monitor()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   769
    monitor = mark->monitor();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   770
    temp = monitor->header();
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   771
    assert(temp->is_neutral(), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   772
    hash = temp->hash();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   773
    if (hash) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   774
      return hash;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   775
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   776
    // Skip to the following code to reduce code size
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   777
  } else if (Self->is_lock_owned((address)mark->locker())) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   778
    temp = mark->displaced_mark_helper(); // this is a lightweight monitor owned
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   779
    assert(temp->is_neutral(), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   780
    hash = temp->hash();              // by current thread, check if the displaced
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   781
    if (hash) {                       // header contains hash code
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   782
      return hash;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   783
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   784
    // WARNING:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   785
    //   The displaced header is strictly immutable.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   786
    // It can NOT be changed in ANY cases. So we have
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   787
    // to inflate the header into heavyweight monitor
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   788
    // even the current thread owns the lock. The reason
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   789
    // is the BasicLock (stack slot) will be asynchronously
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   790
    // read by other threads during the inflate() function.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   791
    // Any change to stack may not propagate to other threads
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   792
    // correctly.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   793
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   794
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   795
  // Inflate the monitor to set hash code
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
   796
  monitor = ObjectSynchronizer::inflate(Self, obj, inflate_cause_hash_code);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   797
  // Load displaced header and check it has hash code
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   798
  mark = monitor->header();
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   799
  assert(mark->is_neutral(), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   800
  hash = mark->hash();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   801
  if (hash == 0) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   802
    hash = get_next_hash(Self, obj);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   803
    temp = mark->copy_set_hash(hash); // merge hash code into header
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   804
    assert(temp->is_neutral(), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   805
    test = (markOop) Atomic::cmpxchg_ptr(temp, monitor, mark);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   806
    if (test != mark) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   807
      // The only update to the header in the monitor (outside GC)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   808
      // is install the hash code. If someone add new usage of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   809
      // displaced header, please update this code
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   810
      hash = test->hash();
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   811
      assert(test->is_neutral(), "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   812
      assert(hash != 0, "Trivial unexpected object/monitor header usage.");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   813
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   814
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   815
  // We finally get the hash
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   816
  return hash;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   819
// Deprecated -- use FastHashCode() instead.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   821
intptr_t ObjectSynchronizer::identity_hash_value_for(Handle obj) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   822
  return FastHashCode(Thread::current(), obj());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   826
bool ObjectSynchronizer::current_thread_holds_lock(JavaThread* thread,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   827
                                                   Handle h_obj) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   828
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   829
    BiasedLocking::revoke_and_rebias(h_obj, false, thread);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   830
    assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   831
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   832
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   833
  assert(thread == JavaThread::current(), "Can only be called on current thread");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   834
  oop obj = h_obj();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   835
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   836
  markOop mark = ReadStableMark(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   838
  // Uncontended case, header points to stack
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   839
  if (mark->has_locker()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   840
    return thread->is_lock_owned((address)mark->locker());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   842
  // Contended case, header points to ObjectMonitor (tagged pointer)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   843
  if (mark->has_monitor()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   844
    ObjectMonitor* monitor = mark->monitor();
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   845
    return monitor->is_entered(thread) != 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   847
  // Unlocked case, header in place
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   848
  assert(mark->is_neutral(), "sanity check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   849
  return false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   852
// Be aware of this method could revoke bias of the lock object.
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22190
diff changeset
   853
// This method queries the ownership of the lock handle specified by 'h_obj'.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   854
// If the current thread owns the lock, it returns owner_self. If no
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   855
// thread owns the lock, it returns owner_none. Otherwise, it will return
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22190
diff changeset
   856
// owner_other.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   857
ObjectSynchronizer::LockOwnership ObjectSynchronizer::query_lock_ownership
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   858
(JavaThread *self, Handle h_obj) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   859
  // The caller must beware this method can revoke bias, and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   860
  // revocation can result in a safepoint.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   861
  assert(!SafepointSynchronize::is_at_safepoint(), "invariant");
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   862
  assert(self->thread_state() != _thread_blocked, "invariant");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   864
  // Possible mark states: neutral, biased, stack-locked, inflated
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   865
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   866
  if (UseBiasedLocking && h_obj()->mark()->has_bias_pattern()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   867
    // CASE: biased
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   868
    BiasedLocking::revoke_and_rebias(h_obj, false, self);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   869
    assert(!h_obj->mark()->has_bias_pattern(),
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   870
           "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   871
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   873
  assert(self == JavaThread::current(), "Can only be called on current thread");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   874
  oop obj = h_obj();
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   875
  markOop mark = ReadStableMark(obj);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   876
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   877
  // CASE: stack-locked.  Mark points to a BasicLock on the owner's stack.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   878
  if (mark->has_locker()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   879
    return self->is_lock_owned((address)mark->locker()) ?
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   880
      owner_self : owner_other;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   881
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   883
  // CASE: inflated. Mark (tagged pointer) points to an objectMonitor.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   884
  // The Object:ObjectMonitor relationship is stable as long as we're
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   885
  // not at a safepoint.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   886
  if (mark->has_monitor()) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   887
    void * owner = mark->monitor()->_owner;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   888
    if (owner == NULL) return owner_none;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   889
    return (owner == self ||
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   890
            self->is_lock_owned((address)owner)) ? owner_self : owner_other;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   891
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   892
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   893
  // CASE: neutral
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   894
  assert(mark->is_neutral(), "sanity check");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   895
  return owner_none;           // it's unlocked
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   896
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   898
// FIXME: jvmti should call this
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   899
JavaThread* ObjectSynchronizer::get_lock_owner(Handle h_obj, bool doLock) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   900
  if (UseBiasedLocking) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   901
    if (SafepointSynchronize::is_at_safepoint()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   902
      BiasedLocking::revoke_at_safepoint(h_obj);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   903
    } else {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   904
      BiasedLocking::revoke_and_rebias(h_obj, false, JavaThread::current());
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   905
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   906
    assert(!h_obj->mark()->has_bias_pattern(), "biases should be revoked by now");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   907
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   908
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   909
  oop obj = h_obj();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   910
  address owner = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   911
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   912
  markOop mark = ReadStableMark(obj);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   913
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   914
  // Uncontended case, header points to stack
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   915
  if (mark->has_locker()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   916
    owner = (address) mark->locker();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   917
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   918
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   919
  // Contended case, header points to ObjectMonitor (tagged pointer)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   920
  if (mark->has_monitor()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   921
    ObjectMonitor* monitor = mark->monitor();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   922
    assert(monitor != NULL, "monitor should be non-null");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   923
    owner = (address) monitor->owner();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   924
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   925
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   926
  if (owner != NULL) {
15853
1c4e16950e96 8007476: assert(the_owner != NULL) failed: Did not find owning Java thread for lock word address
dcubed
parents: 15475
diff changeset
   927
    // owning_thread_from_monitor_owner() may also return NULL here
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   928
    return Threads::owning_thread_from_monitor_owner(owner, doLock);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   929
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   930
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   931
  // Unlocked case, header in place
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   932
  // Cannot have assertion since this object may have been
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   933
  // locked by another thread when reaching here.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   934
  // assert(mark->is_neutral(), "sanity check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   935
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   936
  return NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   937
}
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   938
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   939
// Visitors ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   940
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   941
void ObjectSynchronizer::monitors_iterate(MonitorClosure* closure) {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   942
  PaddedEnd<ObjectMonitor> * block =
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   943
    (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   944
  while (block != NULL) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   945
    assert(block->object() == CHAINMARKER, "must be a block header");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   946
    for (int i = _BLOCKSIZE - 1; i > 0; i--) {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   947
      ObjectMonitor* mid = (ObjectMonitor *)(block + i);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   948
      oop object = (oop)mid->object();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   949
      if (object != NULL) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   950
        closure->do_monitor(mid);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   951
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   952
    }
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   953
    block = (PaddedEnd<ObjectMonitor> *)block->FreeNext;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   957
// Get the next block in the block list.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   958
static inline ObjectMonitor* next(ObjectMonitor* block) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   959
  assert(block->object() == CHAINMARKER, "must be a block header");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
   960
  block = block->FreeNext;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   961
  assert(block == NULL || block->object() == CHAINMARKER, "must be a block header");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   962
  return block;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   966
void ObjectSynchronizer::oops_do(OopClosure* f) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   967
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   968
  PaddedEnd<ObjectMonitor> * block =
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   969
    (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
   970
  for (; block != NULL; block = (PaddedEnd<ObjectMonitor> *)next(block)) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   971
    assert(block->object() == CHAINMARKER, "must be a block header");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   972
    for (int i = 1; i < _BLOCKSIZE; i++) {
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   973
      ObjectMonitor* mid = (ObjectMonitor *)&block[i];
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   974
      if (mid->object() != NULL) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   975
        f->do_oop((oop*)mid->object_addr());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
   982
// -----------------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
// ObjectMonitor Lifecycle
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
// -----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
// Inflation unlinks monitors from the global gFreeList and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
// associates them with objects.  Deflation -- which occurs at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
// STW-time -- disassociates idle monitors from objects.  Such
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
// scavenged monitors are returned to the gFreeList.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
//
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
   990
// The global list is protected by gListLock.  All the critical sections
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
// are short and operate in constant-time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
// ObjectMonitors reside in type-stable memory (TSM) and are immortal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
// Lifecycle:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
// --   unassigned and on the global free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
// --   unassigned and on a thread's private omFreeList
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
// --   assigned to an object.  The object is inflated and the mark refers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
//      to the objectmonitor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1002
// Constraining monitor pool growth via MonitorBound ...
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1003
//
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1004
// The monitor pool is grow-only.  We scavenge at STW safepoint-time, but the
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1005
// the rate of scavenging is driven primarily by GC.  As such,  we can find
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1006
// an inordinate number of monitors in circulation.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1007
// To avoid that scenario we can artificially induce a STW safepoint
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1008
// if the pool appears to be growing past some reasonable bound.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1009
// Generally we favor time in space-time tradeoffs, but as there's no
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1010
// natural back-pressure on the # of extant monitors we need to impose some
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1011
// type of limit.  Beware that if MonitorBound is set to too low a value
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1012
// we could just loop. In addition, if MonitorBound is set to a low value
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1013
// we'll incur more safepoints, which are harmful to performance.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1014
// See also: GuaranteedSafepointInterval
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1015
//
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1016
// The current implementation uses asynchronous VM operations.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1017
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1018
static void InduceScavenge(Thread * Self, const char * Whence) {
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1019
  // Induce STW safepoint to trim monitors
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1020
  // Ultimately, this results in a call to deflate_idle_monitors() in the near future.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1021
  // More precisely, trigger an asynchronous STW safepoint as the number
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1022
  // of active monitors passes the specified threshold.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1023
  // TODO: assert thread state is reasonable
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1024
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1025
  if (ForceMonitorScavenge == 0 && Atomic::xchg (1, &ForceMonitorScavenge) == 0) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1026
    if (ObjectMonitor::Knob_Verbose) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1027
      tty->print_cr("INFO: Monitor scavenge - Induced STW @%s (%d)",
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1028
                    Whence, ForceMonitorScavenge) ;
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1029
      tty->flush();
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1030
    }
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1031
    // Induce a 'null' safepoint to scavenge monitors
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1032
    // Must VM_Operation instance be heap allocated as the op will be enqueue and posted
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1033
    // to the VMthread and have a lifespan longer than that of this activation record.
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1034
    // The VMThread will delete the op when completed.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1035
    VMThread::execute(new VM_ForceAsyncSafepoint());
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1036
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1037
    if (ObjectMonitor::Knob_Verbose) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1038
      tty->print_cr("INFO: Monitor scavenge - STW posted @%s (%d)",
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1039
                    Whence, ForceMonitorScavenge) ;
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1040
      tty->flush();
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1041
    }
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1042
  }
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1043
}
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1044
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1045
void ObjectSynchronizer::verifyInUse(Thread *Self) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1046
  ObjectMonitor* mid;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1047
  int in_use_tally = 0;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1048
  for (mid = Self->omInUseList; mid != NULL; mid = mid->FreeNext) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1049
    in_use_tally++;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1050
  }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1051
  assert(in_use_tally == Self->omInUseCount, "in-use count off");
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1052
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1053
  int free_tally = 0;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1054
  for (mid = Self->omFreeList; mid != NULL; mid = mid->FreeNext) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1055
    free_tally++;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1056
  }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1057
  assert(free_tally == Self->omFreeCount, "free count off");
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1058
}
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1059
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 35934
diff changeset
  1060
ObjectMonitor* ObjectSynchronizer::omAlloc(Thread * Self) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1061
  // A large MAXPRIVATE value reduces both list lock contention
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1062
  // and list coherency traffic, but also tends to increase the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1063
  // number of objectMonitors in circulation as well as the STW
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1064
  // scavenge costs.  As usual, we lean toward time in space-time
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1065
  // tradeoffs.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1066
  const int MAXPRIVATE = 1024;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1067
  for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1068
    ObjectMonitor * m;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1070
    // 1: try to allocate from the thread's local omFreeList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1071
    // Threads will attempt to allocate first from their local list, then
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1072
    // from the global list, and only after those attempts fail will the thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1073
    // attempt to instantiate new monitors.   Thread-local free lists take
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1074
    // heat off the gListLock and improve allocation latency, as well as reducing
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1075
    // coherency traffic on the shared global list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1076
    m = Self->omFreeList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1077
    if (m != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1078
      Self->omFreeList = m->FreeNext;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1079
      Self->omFreeCount--;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1080
      // CONSIDER: set m->FreeNext = BAD -- diagnostic hygiene
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1081
      guarantee(m->object() == NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1082
      if (MonitorInUseLists) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1083
        m->FreeNext = Self->omInUseList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1084
        Self->omInUseList = m;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1085
        Self->omInUseCount++;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1086
        if (ObjectMonitor::Knob_VerifyInUse) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1087
          verifyInUse(Self);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
        }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1089
      } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1090
        m->FreeNext = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1091
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1092
      return m;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1093
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1095
    // 2: try to allocate from the global gFreeList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1096
    // CONSIDER: use muxTry() instead of muxAcquire().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1097
    // If the muxTry() fails then drop immediately into case 3.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1098
    // If we're using thread-local free lists then try
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1099
    // to reprovision the caller's free list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1100
    if (gFreeList != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1101
      // Reprovision the thread's omFreeList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1102
      // Use bulk transfers to reduce the allocation rate and heat
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1103
      // on various locks.
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1104
      Thread::muxAcquire(&gListLock, "omAlloc");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1105
      for (int i = Self->omFreeProvision; --i >= 0 && gFreeList != NULL;) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1106
        gMonitorFreeCount--;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1107
        ObjectMonitor * take = gFreeList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1108
        gFreeList = take->FreeNext;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1109
        guarantee(take->object() == NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1110
        guarantee(!take->is_busy(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1111
        take->Recycle();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1112
        omRelease(Self, take, false);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1113
      }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1114
      Thread::muxRelease(&gListLock);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1115
      Self->omFreeProvision += 1 + (Self->omFreeProvision/2);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1116
      if (Self->omFreeProvision > MAXPRIVATE) Self->omFreeProvision = MAXPRIVATE;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1117
      TEVENT(omFirst - reprovision);
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1118
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1119
      const int mx = MonitorBound;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1120
      if (mx > 0 && (gMonitorPopulation-gMonitorFreeCount) > mx) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1121
        // We can't safely induce a STW safepoint from omAlloc() as our thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1122
        // state may not be appropriate for such activities and callers may hold
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1123
        // naked oops, so instead we defer the action.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1124
        InduceScavenge(Self, "omAlloc");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1125
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1126
      continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1127
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1129
    // 3: allocate a block of new ObjectMonitors
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1130
    // Both the local and global free lists are empty -- resort to malloc().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1131
    // In the current implementation objectMonitors are TSM - immortal.
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1132
    // Ideally, we'd write "new ObjectMonitor[_BLOCKSIZE], but we want
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1133
    // each ObjectMonitor to start at the beginning of a cache line,
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1134
    // so we use align_size_up().
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1135
    // A better solution would be to use C++ placement-new.
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1136
    // BEWARE: As it stands currently, we don't run the ctors!
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1137
    assert(_BLOCKSIZE > 1, "invariant");
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1138
    size_t neededsize = sizeof(PaddedEnd<ObjectMonitor>) * _BLOCKSIZE;
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1139
    PaddedEnd<ObjectMonitor> * temp;
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1140
    size_t aligned_size = neededsize + (DEFAULT_CACHE_LINE_SIZE - 1);
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1141
    void* real_malloc_addr = (void *)NEW_C_HEAP_ARRAY(char, aligned_size,
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1142
                                                      mtInternal);
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1143
    temp = (PaddedEnd<ObjectMonitor> *)
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1144
             align_size_up((intptr_t)real_malloc_addr,
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1145
                           DEFAULT_CACHE_LINE_SIZE);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1147
    // NOTE: (almost) no way to recover if allocation failed.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1148
    // We might be able to induce a STW safepoint and scavenge enough
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1149
    // objectMonitors to permit progress.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1150
    if (temp == NULL) {
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1151
      vm_exit_out_of_memory(neededsize, OOM_MALLOC_ERROR,
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1152
                            "Allocate ObjectMonitors");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1153
    }
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1154
    (void)memset((void *) temp, 0, neededsize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1156
    // Format the block.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1157
    // initialize the linked list, each monitor points to its next
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1158
    // forming the single linked free list, the very first monitor
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1159
    // will points to next block, which forms the block list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1160
    // The trick of using the 1st element in the block as gBlockList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1161
    // linkage should be reconsidered.  A better implementation would
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1162
    // look like: class Block { Block * next; int N; ObjectMonitor Body [N] ; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1164
    for (int i = 1; i < _BLOCKSIZE; i++) {
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1165
      temp[i].FreeNext = (ObjectMonitor *)&temp[i+1];
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1166
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1168
    // terminate the last monitor as the end of list
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1169
    temp[_BLOCKSIZE - 1].FreeNext = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1171
    // Element [0] is reserved for global list linkage
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1172
    temp[0].set_object(CHAINMARKER);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1174
    // Consider carving out this thread's current request from the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1175
    // block in hand.  This avoids some lock traffic and redundant
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1176
    // list activity.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1178
    // Acquire the gListLock to manipulate gBlockList and gFreeList.
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1179
    // An Oyama-Taura-Yonezawa scheme might be more efficient.
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1180
    Thread::muxAcquire(&gListLock, "omAlloc [2]");
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1181
    gMonitorPopulation += _BLOCKSIZE-1;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1182
    gMonitorFreeCount += _BLOCKSIZE-1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1184
    // Add the new block to the list of extant blocks (gBlockList).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1185
    // The very first objectMonitor in a block is reserved and dedicated.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1186
    // It serves as blocklist "next" linkage.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1187
    temp[0].FreeNext = gBlockList;
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1188
    // There are lock-free uses of gBlockList so make sure that
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1189
    // the previous stores happen before we update gBlockList.
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1190
    OrderAccess::release_store_ptr(&gBlockList, temp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1192
    // Add the new string of objectMonitors to the global free list
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1193
    temp[_BLOCKSIZE - 1].FreeNext = gFreeList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1194
    gFreeList = temp + 1;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1195
    Thread::muxRelease(&gListLock);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1196
    TEVENT(Allocate block of monitors);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1197
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
// Place "m" on the caller's private per-thread omFreeList.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
// In practice there's no need to clamp or limit the number of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
// monitors on a thread's omFreeList as the only time we'll call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
// omRelease is to return a monitor to the free list after a CAS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
// attempt failed.  This doesn't allow unbounded #s of monitors to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
// accumulate on a thread's free list.
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1206
//
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1207
// Key constraint: all ObjectMonitors on a thread's free list and the global
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1208
// free list must have their object field set to null. This prevents the
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1209
// scavenger -- deflate_idle_monitors -- from reclaiming them.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1211
void ObjectSynchronizer::omRelease(Thread * Self, ObjectMonitor * m,
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1212
                                   bool fromPerThreadAlloc) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1213
  guarantee(m->object() == NULL, "invariant");
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1214
  guarantee(((m->is_busy()|m->_recursions) == 0), "freeing in-use monitor");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1215
  // Remove from omInUseList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1216
  if (MonitorInUseLists && fromPerThreadAlloc) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1217
    ObjectMonitor* cur_mid_in_use = NULL;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1218
    bool extracted = false;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1219
    for (ObjectMonitor* mid = Self->omInUseList; mid != NULL; cur_mid_in_use = mid, mid = mid->FreeNext) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1220
      if (m == mid) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1221
        // extract from per-thread in-use list
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1222
        if (mid == Self->omInUseList) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1223
          Self->omInUseList = mid->FreeNext;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1224
        } else if (cur_mid_in_use != NULL) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1225
          cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1226
        }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1227
        extracted = true;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1228
        Self->omInUseCount--;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1229
        if (ObjectMonitor::Knob_VerifyInUse) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1230
          verifyInUse(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1231
        }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1232
        break;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1233
      }
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1234
    }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1235
    assert(extracted, "Should have extracted from in-use list");
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1236
  }
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1237
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1238
  // FreeNext is used for both omInUseList and omFreeList, so clear old before setting new
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1239
  m->FreeNext = Self->omFreeList;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1240
  Self->omFreeList = m;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1241
  Self->omFreeCount++;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
// Return the monitors of a moribund thread's local free list to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
// the global free list.  Typically a thread calls omFlush() when
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
// it's dying.  We could also consider having the VM thread steal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
// monitors from threads that have not run java code over a few
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
// consecutive STW safepoints.  Relatedly, we might decay
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
// omFreeProvision at STW safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
//
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1251
// Also return the monitors of a moribund thread's omInUseList to
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1252
// a global gOmInUseList under the global list lock so these
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1253
// will continue to be scanned.
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1254
//
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
// We currently call omFlush() from the Thread:: dtor _after the thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
// has been excised from the thread list and is no longer a mutator.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
// That means that omFlush() can run concurrently with a safepoint and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
// the scavenge operator.  Calling omFlush() from JavaThread::exit() might
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
// be a better choice as we could safely reason that that the JVM is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
// not at a safepoint at the time of the call, and thus there could
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
// be not inopportune interleavings between omFlush() and the scavenge
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
// operator.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1264
void ObjectSynchronizer::omFlush(Thread * Self) {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1265
  ObjectMonitor * list = Self->omFreeList;  // Null-terminated SLL
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1266
  Self->omFreeList = NULL;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1267
  ObjectMonitor * tail = NULL;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1268
  int tally = 0;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1269
  if (list != NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1270
    ObjectMonitor * s;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1271
    // The thread is going away, the per-thread free monitors
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1272
    // are freed via set_owner(NULL)
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1273
    // Link them to tail, which will be linked into the global free list
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1274
    // gFreeList below, under the gListLock
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1275
    for (s = list; s != NULL; s = s->FreeNext) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1276
      tally++;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1277
      tail = s;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1278
      guarantee(s->object() == NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1279
      guarantee(!s->is_busy(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1280
      s->set_owner(NULL);   // redundant but good hygiene
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1281
      TEVENT(omFlush - Move one);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
    }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1283
    guarantee(tail != NULL && list != NULL, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1284
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1286
  ObjectMonitor * inUseList = Self->omInUseList;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1287
  ObjectMonitor * inUseTail = NULL;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1288
  int inUseTally = 0;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1289
  if (inUseList != NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1290
    Self->omInUseList = NULL;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1291
    ObjectMonitor *cur_om;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1292
    // The thread is going away, however the omInUseList inflated
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1293
    // monitors may still be in-use by other threads.
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1294
    // Link them to inUseTail, which will be linked into the global in-use list
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1295
    // gOmInUseList below, under the gListLock
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1296
    for (cur_om = inUseList; cur_om != NULL; cur_om = cur_om->FreeNext) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1297
      inUseTail = cur_om;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1298
      inUseTally++;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1299
    }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1300
    assert(Self->omInUseCount == inUseTally, "in-use count off");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1301
    Self->omInUseCount = 0;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1302
    guarantee(inUseTail != NULL && inUseList != NULL, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1303
  }
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1304
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1305
  Thread::muxAcquire(&gListLock, "omFlush");
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1306
  if (tail != NULL) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1307
    tail->FreeNext = gFreeList;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1308
    gFreeList = list;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1309
    gMonitorFreeCount += tally;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1310
  }
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1311
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1312
  if (inUseTail != NULL) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1313
    inUseTail->FreeNext = gOmInUseList;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1314
    gOmInUseList = inUseList;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1315
    gOmInUseCount += inUseTally;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1316
  }
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1317
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1318
  Thread::muxRelease(&gListLock);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1319
  TEVENT(omFlush);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
// Fast path code shared by multiple functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
ObjectMonitor* ObjectSynchronizer::inflate_helper(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  markOop mark = obj->mark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  if (mark->has_monitor()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
    assert(ObjectSynchronizer::verify_objmon_isinpool(mark->monitor()), "monitor is invalid");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
    assert(mark->monitor()->header()->is_neutral(), "monitor must record a good object header");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
    return mark->monitor();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1330
  return ObjectSynchronizer::inflate(Thread::current(),
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1331
                                     obj,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1332
                                     inflate_cause_vm_internal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 35934
diff changeset
  1335
ObjectMonitor* ObjectSynchronizer::inflate(Thread * Self,
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1336
                                                     oop object,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1337
                                                     const InflateCause cause) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1338
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  // Inflate mutates the heap ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  // Relaxing assertion for bug 6320749.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1341
  assert(Universe::verify_in_progress() ||
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1342
         !SafepointSynchronize::is_at_safepoint(), "invariant");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1344
  EventJavaMonitorInflate event;
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1345
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  for (;;) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1347
    const markOop mark = object->mark();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1348
    assert(!mark->has_bias_pattern(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1349
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1350
    // The mark can be in one of the following states:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1351
    // *  Inflated     - just return
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1352
    // *  Stack-locked - coerce it to inflated
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1353
    // *  INFLATING    - busy wait for conversion to complete
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1354
    // *  Neutral      - aggressively inflate the object.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1355
    // *  BIASED       - Illegal.  We should never see this
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1357
    // CASE: inflated
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1358
    if (mark->has_monitor()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1359
      ObjectMonitor * inf = mark->monitor();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1360
      assert(inf->header()->is_neutral(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1361
      assert(inf->object() == object, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1362
      assert(ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1363
      event.cancel(); // let's not post an inflation event, unless we did the deed ourselves
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1364
      return inf;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1365
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1366
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1367
    // CASE: inflation in progress - inflating over a stack-lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1368
    // Some other thread is converting from stack-locked to inflated.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1369
    // Only that thread can complete inflation -- other threads must wait.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1370
    // The INFLATING value is transient.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1371
    // Currently, we spin/yield/park and poll the markword, waiting for inflation to finish.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1372
    // We could always eliminate polling by parking the thread on some auxiliary list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1373
    if (mark == markOopDesc::INFLATING()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1374
      TEVENT(Inflate: spin while INFLATING);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1375
      ReadStableMark(object);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1376
      continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1377
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1379
    // CASE: stack-locked
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1380
    // Could be stack-locked either by this thread or by some other thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1381
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1382
    // Note that we allocate the objectmonitor speculatively, _before_ attempting
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1383
    // to install INFLATING into the mark word.  We originally installed INFLATING,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1384
    // allocated the objectmonitor, and then finally STed the address of the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1385
    // objectmonitor into the mark.  This was correct, but artificially lengthened
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1386
    // the interval in which INFLATED appeared in the mark, thus increasing
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1387
    // the odds of inflation contention.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1388
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1389
    // We now use per-thread private objectmonitor free lists.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1390
    // These list are reprovisioned from the global free list outside the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1391
    // critical INFLATING...ST interval.  A thread can transfer
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1392
    // multiple objectmonitors en-mass from the global free list to its local free list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1393
    // This reduces coherency traffic and lock contention on the global free list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1394
    // Using such local free lists, it doesn't matter if the omAlloc() call appears
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1395
    // before or after the CAS(INFLATING) operation.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1396
    // See the comments in omAlloc().
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1398
    if (mark->has_locker()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1399
      ObjectMonitor * m = omAlloc(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1400
      // Optimistically prepare the objectmonitor - anticipate successful CAS
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1401
      // We do this before the CAS in order to minimize the length of time
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1402
      // in which INFLATING appears in the mark.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1403
      m->Recycle();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1404
      m->_Responsible  = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1405
      m->_recursions   = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1406
      m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;   // Consider: maintain by type/class
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1407
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1408
      markOop cmp = (markOop) Atomic::cmpxchg_ptr(markOopDesc::INFLATING(), object->mark_addr(), mark);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1409
      if (cmp != mark) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1410
        omRelease(Self, m, true);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1411
        continue;       // Interference -- just retry
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1414
      // We've successfully installed INFLATING (0) into the mark-word.
32623
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 32614
diff changeset
  1415
      // This is the only case where 0 will appear in a mark-word.
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1416
      // Only the singular thread that successfully swings the mark-word
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1417
      // to 0 can perform (or more precisely, complete) inflation.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
      //
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1419
      // Why do we CAS a 0 into the mark-word instead of just CASing the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1420
      // mark-word from the stack-locked value directly to the new inflated state?
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1421
      // Consider what happens when a thread unlocks a stack-locked object.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1422
      // It attempts to use CAS to swing the displaced header value from the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1423
      // on-stack basiclock back into the object header.  Recall also that the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1424
      // header value (hashcode, etc) can reside in (a) the object header, or
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1425
      // (b) a displaced header associated with the stack-lock, or (c) a displaced
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1426
      // header in an objectMonitor.  The inflate() routine must copy the header
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1427
      // value from the basiclock on the owner's stack to the objectMonitor, all
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1428
      // the while preserving the hashCode stability invariants.  If the owner
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1429
      // decides to release the lock while the value is 0, the unlock will fail
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1430
      // and control will eventually pass from slow_exit() to inflate.  The owner
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1431
      // will then spin, waiting for the 0 value to disappear.   Put another way,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1432
      // the 0 causes the owner to stall if the owner happens to try to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1433
      // drop the lock (restoring the header from the basiclock to the object)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1434
      // while inflation is in-progress.  This protocol avoids races that might
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1435
      // would otherwise permit hashCode values to change or "flicker" for an object.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1436
      // Critically, while object->mark is 0 mark->displaced_mark_helper() is stable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1437
      // 0 serves as a "BUSY" inflate-in-progress indicator.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1440
      // fetch the displaced mark from the owner's stack.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1441
      // The owner can't die or unwind past the lock while our INFLATING
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1442
      // object is in the mark.  Furthermore the owner can't complete
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1443
      // an unlock on the object, either.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1444
      markOop dmw = mark->displaced_mark_helper();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1445
      assert(dmw->is_neutral(), "invariant");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1447
      // Setup monitor fields to proper values -- prepare the monitor
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1448
      m->set_header(dmw);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1450
      // Optimization: if the mark->locker stack address is associated
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1451
      // with this thread we could simply set m->_owner = Self.
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1452
      // Note that a thread can inflate an object
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1453
      // that it has stack-locked -- as might happen in wait() -- directly
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1454
      // with CAS.  That is, we can avoid the xchg-NULL .... ST idiom.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1455
      m->set_owner(mark->locker());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
      m->set_object(object);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1457
      // TODO-FIXME: assert BasicLock->dhw != 0.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1459
      // Must preserve store ordering. The monitor state must
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1460
      // be stable at the time of publishing the monitor address.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1461
      guarantee(object->mark() == markOopDesc::INFLATING(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1462
      object->release_set_mark(markOopDesc::encode(m));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1464
      // Hopefully the performance counters are allocated on distinct cache lines
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1465
      // to avoid false sharing on MP systems ...
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1466
      OM_PERFDATA_OP(Inflations, inc());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1467
      TEVENT(Inflate: overwrite stacklock);
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1468
      if (log_is_enabled(Debug, monitorinflation)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
        if (object->is_instance()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
          ResourceMark rm;
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1471
          log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1472
                                      p2i(object), p2i(object->mark()),
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1473
                                      object->klass()->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
      }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1476
      if (event.should_commit()) {
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1477
        post_monitor_inflate_event(event, object, cause);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1478
      }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1479
      return m;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1480
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1481
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1482
    // CASE: neutral
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1483
    // TODO-FIXME: for entry we currently inflate and then try to CAS _owner.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1484
    // If we know we're inflating for entry it's better to inflate by swinging a
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1485
    // pre-locked objectMonitor pointer into the object header.   A successful
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1486
    // CAS inflates the object *and* confers ownership to the inflating thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1487
    // In the current implementation we use a 2-step mechanism where we CAS()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1488
    // to inflate and then CAS() again to try to swing _owner from NULL to Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1489
    // An inflateTry() method that we could call from fast_enter() and slow_enter()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1490
    // would be useful.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1491
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1492
    assert(mark->is_neutral(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1493
    ObjectMonitor * m = omAlloc(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1494
    // prepare m for installation - set monitor to initial state
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1495
    m->Recycle();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1496
    m->set_header(mark);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1497
    m->set_owner(NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1498
    m->set_object(object);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1499
    m->_recursions   = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1500
    m->_Responsible  = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1501
    m->_SpinDuration = ObjectMonitor::Knob_SpinLimit;       // consider: keep metastats by type/class
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1502
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1503
    if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1504
      m->set_object(NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1505
      m->set_owner(NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1506
      m->Recycle();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1507
      omRelease(Self, m, true);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1508
      m = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1509
      continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1510
      // interference - the markword changed - just retry.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1511
      // The state-transitions are one-way, so there's no chance of
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1512
      // live-lock -- "Inflated" is an absorbing state.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1513
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1514
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1515
    // Hopefully the performance counters are allocated on distinct
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1516
    // cache lines to avoid false sharing on MP systems ...
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1517
    OM_PERFDATA_OP(Inflations, inc());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1518
    TEVENT(Inflate: overwrite neutral);
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1519
    if (log_is_enabled(Debug, monitorinflation)) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1520
      if (object->is_instance()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1521
        ResourceMark rm;
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1522
        log_debug(monitorinflation)("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1523
                                    p2i(object), p2i(object->mark()),
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1524
                                    object->klass()->external_name());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1525
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1526
    }
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1527
    if (event.should_commit()) {
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1528
      post_monitor_inflate_event(event, object, cause);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1529
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1530
    return m;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
// Deflate_idle_monitors() is called at all safepoints, immediately
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
// after all mutators are stopped, but before any objects have moved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
// It traverses the list of known monitors, deflating where possible.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
// The scavenged monitor are returned to the monitor free list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
// Beware that we scavenge at *every* stop-the-world point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
// Having a large number of monitors in-circulation negatively
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
// impacts the performance of some applications (e.g., PointBase).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
// Broadly, we want to minimize the # of monitors in circulation.
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1544
//
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1545
// We have added a flag, MonitorInUseLists, which creates a list
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1546
// of active monitors for each thread. deflate_idle_monitors()
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1547
// only scans the per-thread in-use lists. omAlloc() puts all
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1548
// assigned monitors on the per-thread list. deflate_idle_monitors()
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1549
// returns the non-busy monitors to the global free list.
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1550
// When a thread dies, omFlush() adds the list of active monitors for
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1551
// that thread to a global gOmInUseList acquiring the
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1552
// global list lock. deflate_idle_monitors() acquires the global
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1553
// list lock to scan for non-busy monitors to the global free list.
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1554
// An alternative could have used a single global in-use list. The
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1555
// downside would have been the additional cost of acquiring the global list lock
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1556
// for every omAlloc().
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
// Perversely, the heap size -- and thus the STW safepoint rate --
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
// typically drives the scavenge rate.  Large heaps can mean infrequent GC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
// which in turn can mean large(r) numbers of objectmonitors in circulation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
// This is an unfortunate aspect of this design.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1563
enum ManifestConstants {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1564
  ClearResponsibleAtSTW = 0
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1565
};
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1566
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1567
// Deflate a single monitor if not in-use
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1568
// Return true if deflated, false if in-use
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1569
bool ObjectSynchronizer::deflate_monitor(ObjectMonitor* mid, oop obj,
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1570
                                         ObjectMonitor** freeHeadp,
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1571
                                         ObjectMonitor** freeTailp) {
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1572
  bool deflated;
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1573
  // Normal case ... The monitor is associated with obj.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1574
  guarantee(obj->mark() == markOopDesc::encode(mid), "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1575
  guarantee(mid == obj->mark()->monitor(), "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1576
  guarantee(mid->header()->is_neutral(), "invariant");
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1577
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1578
  if (mid->is_busy()) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1579
    if (ClearResponsibleAtSTW) mid->_Responsible = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1580
    deflated = false;
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1581
  } else {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1582
    // Deflate the monitor if it is no longer being used
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1583
    // It's idle - scavenge and return to the global free list
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1584
    // plain old deflation ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1585
    TEVENT(deflate_idle_monitors - scavenge1);
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1586
    if (log_is_enabled(Debug, monitorinflation)) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1587
      if (obj->is_instance()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1588
        ResourceMark rm;
35171
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1589
        log_debug(monitorinflation)("Deflating object " INTPTR_FORMAT " , "
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1590
                                    "mark " INTPTR_FORMAT " , type %s",
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1591
                                    p2i(obj), p2i(obj->mark()),
cf7d5a1d0662 8145153: Convert TraceMonitorInflation to Unified Logging
rprotacio
parents: 33595
diff changeset
  1592
                                    obj->klass()->external_name());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1593
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1594
    }
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1595
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1596
    // Restore the header back to obj
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1597
    obj->release_set_mark(mid->header());
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1598
    mid->clear();
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1599
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1600
    assert(mid->object() == NULL, "invariant");
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1601
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1602
    // Move the object to the working free list defined by freeHeadp, freeTailp
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1603
    if (*freeHeadp == NULL) *freeHeadp = mid;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1604
    if (*freeTailp != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1605
      ObjectMonitor * prevtail = *freeTailp;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1606
      assert(prevtail->FreeNext == NULL, "cleaned up deflated?");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1607
      prevtail->FreeNext = mid;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1608
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1609
    *freeTailp = mid;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1610
    deflated = true;
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1611
  }
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1612
  return deflated;
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1613
}
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1614
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1615
// Walk a given monitor list, and deflate idle monitors
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1616
// The given list could be a per-thread list or a global list
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1617
// Caller acquires gListLock
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1618
int ObjectSynchronizer::deflate_monitor_list(ObjectMonitor** listHeadp,
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1619
                                             ObjectMonitor** freeHeadp,
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1620
                                             ObjectMonitor** freeTailp) {
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1621
  ObjectMonitor* mid;
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1622
  ObjectMonitor* next;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1623
  ObjectMonitor* cur_mid_in_use = NULL;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1624
  int deflated_count = 0;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1625
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1626
  for (mid = *listHeadp; mid != NULL;) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1627
    oop obj = (oop) mid->object();
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1628
    if (obj != NULL && deflate_monitor(mid, obj, freeHeadp, freeTailp)) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1629
      // if deflate_monitor succeeded,
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1630
      // extract from per-thread in-use list
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1631
      if (mid == *listHeadp) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1632
        *listHeadp = mid->FreeNext;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1633
      } else if (cur_mid_in_use != NULL) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1634
        cur_mid_in_use->FreeNext = mid->FreeNext; // maintain the current thread in-use list
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1635
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1636
      next = mid->FreeNext;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1637
      mid->FreeNext = NULL;  // This mid is current tail in the freeHeadp list
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1638
      mid = next;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1639
      deflated_count++;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1640
    } else {
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1641
      cur_mid_in_use = mid;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1642
      mid = mid->FreeNext;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1643
    }
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1644
  }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1645
  return deflated_count;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1646
}
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1647
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
void ObjectSynchronizer::deflate_idle_monitors() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1650
  int nInuse = 0;              // currently associated with objects
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1651
  int nInCirculation = 0;      // extant
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1652
  int nScavenged = 0;          // reclaimed
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1653
  bool deflated = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1655
  ObjectMonitor * freeHeadp = NULL;  // Local SLL of scavenged monitors
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1656
  ObjectMonitor * freeTailp = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1658
  TEVENT(deflate_idle_monitors);
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1659
  // Prevent omFlush from changing mids in Thread dtor's during deflation
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1660
  // And in case the vm thread is acquiring a lock during a safepoint
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1661
  // See e.g. 6320749
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1662
  Thread::muxAcquire(&gListLock, "scavenge - return");
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1663
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1664
  if (MonitorInUseLists) {
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1665
    int inUse = 0;
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1666
    for (JavaThread* cur = Threads::first(); cur != NULL; cur = cur->next()) {
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1667
      nInCirculation+= cur->omInUseCount;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1668
      int deflated_count = deflate_monitor_list(cur->omInUseList_addr(), &freeHeadp, &freeTailp);
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1669
      cur->omInUseCount-= deflated_count;
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1670
      if (ObjectMonitor::Knob_VerifyInUse) {
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1671
        verifyInUse(cur);
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1672
      }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1673
      nScavenged += deflated_count;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1674
      nInuse += cur->omInUseCount;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1675
    }
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1676
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1677
    // For moribund threads, scan gOmInUseList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1678
    if (gOmInUseList) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1679
      nInCirculation += gOmInUseCount;
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1680
      int deflated_count = deflate_monitor_list((ObjectMonitor **)&gOmInUseList, &freeHeadp, &freeTailp);
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1681
      gOmInUseCount-= deflated_count;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1682
      nScavenged += deflated_count;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1683
      nInuse += gOmInUseCount;
5920
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1684
    }
8fdbb85e62d3 6964164: MonitorInUseLists leak of contended objects
acorn
parents: 5712
diff changeset
  1685
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1686
  } else {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1687
    PaddedEnd<ObjectMonitor> * block =
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1688
      (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1689
    for (; block != NULL; block = (PaddedEnd<ObjectMonitor> *)next(block)) {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1690
      // Iterate over all extant monitors - Scavenge all idle monitors.
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1691
      assert(block->object() == CHAINMARKER, "must be a block header");
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1692
      nInCirculation += _BLOCKSIZE;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1693
      for (int i = 1; i < _BLOCKSIZE; i++) {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1694
        ObjectMonitor* mid = (ObjectMonitor*)&block[i];
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1695
        oop obj = (oop)mid->object();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1697
        if (obj == NULL) {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1698
          // The monitor is not associated with an object.
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1699
          // The monitor should either be a thread-specific private
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1700
          // free list or the global free list.
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1701
          // obj == NULL IMPLIES mid->is_busy() == 0
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1702
          guarantee(!mid->is_busy(), "invariant");
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1703
          continue;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1704
        }
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1705
        deflated = deflate_monitor(mid, obj, &freeHeadp, &freeTailp);
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1706
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1707
        if (deflated) {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1708
          mid->FreeNext = NULL;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1709
          nScavenged++;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1710
        } else {
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1711
          nInuse++;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1712
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1717
  gMonitorFreeCount += nScavenged;
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1718
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1719
  // Consider: audit gFreeList to ensure that gMonitorFreeCount and list agree.
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1720
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1721
  if (ObjectMonitor::Knob_Verbose) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1722
    tty->print_cr("INFO: Deflate: InCirc=%d InUse=%d Scavenged=%d "
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1723
                  "ForceMonitorScavenge=%d : pop=%d free=%d",
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1724
                  nInCirculation, nInuse, nScavenged, ForceMonitorScavenge,
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1725
                  gMonitorPopulation, gMonitorFreeCount);
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1726
    tty->flush();
5710
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1727
  }
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1728
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1729
  ForceMonitorScavenge = 0;    // Reset
d664086c0add 6852873: Reduce safepoint cleanup time
acorn
parents: 2526
diff changeset
  1730
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  // Move the scavenged monitors back to the global free list.
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1732
  if (freeHeadp != NULL) {
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1733
    guarantee(freeTailp != NULL && nScavenged > 0, "invariant");
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1734
    assert(freeTailp->FreeNext == NULL, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1735
    // constant-time list splice - prepend scavenged segment to gFreeList
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1736
    freeTailp->FreeNext = gFreeList;
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1737
    gFreeList = freeHeadp;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
  }
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1739
  Thread::muxRelease(&gListLock);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1741
  OM_PERFDATA_OP(Deflations, inc(nScavenged));
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1742
  OM_PERFDATA_OP(MonExtant, set_value(nInCirculation));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
  // TODO: Add objectMonitor leak detection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
  // Audit/inventory the objectMonitors -- make sure they're all accounted for.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1746
  GVars.stwRandom = os::random();
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24424
diff changeset
  1747
  GVars.stwCycle++;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1750
// Monitor cleanup on JavaThread::exit
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1752
// Iterate through monitor cache and attempt to release thread's monitors
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1753
// Gives up on a particular monitor if an exception occurs, but continues
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1754
// the overall iteration, swallowing the exception.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1755
class ReleaseJavaMonitorsClosure: public MonitorClosure {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1756
 private:
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1757
  TRAPS;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1759
 public:
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1760
  ReleaseJavaMonitorsClosure(Thread* thread) : THREAD(thread) {}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1761
  void do_monitor(ObjectMonitor* mid) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1762
    if (mid->owner() == THREAD) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1763
      if (ObjectMonitor::Knob_VerifyMatch != 0) {
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37250
diff changeset
  1764
        ResourceMark rm;
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1765
        Handle obj((oop) mid->object());
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1766
        tty->print("INFO: unexpected locked object:");
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1767
        javaVFrame::print_locked_object_class_name(tty, obj, "locked");
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32623
diff changeset
  1768
        fatal("exiting JavaThread=" INTPTR_FORMAT
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32623
diff changeset
  1769
              " unexpectedly owns ObjectMonitor=" INTPTR_FORMAT,
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
  1770
              p2i(THREAD), p2i(mid));
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 31345
diff changeset
  1771
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1772
      (void)mid->complete_exit(CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1775
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1777
// Release all inflated monitors owned by THREAD.  Lightweight monitors are
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1778
// ignored.  This is meant to be called during JNI thread detach which assumes
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1779
// all remaining monitors are heavyweight.  All exceptions are swallowed.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1780
// Scanning the extant monitor list can be time consuming.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1781
// A simple optimization is to add a per-thread flag that indicates a thread
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1782
// called jni_monitorenter() during its lifetime.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
//
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1784
// Instead of No_Savepoint_Verifier it might be cheaper to
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1785
// use an idiom of the form:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1786
//   auto int tmp = SafepointSynchronize::_safepoint_counter ;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1787
//   <code that must not run at safepoint>
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1788
//   guarantee (((tmp ^ _safepoint_counter) | (tmp & 1)) == 0) ;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1789
// Since the tests are extremely cheap we could leave them enabled
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1790
// for normal product builds.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1792
void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1793
  assert(THREAD == JavaThread::current(), "must be current Java thread");
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35171
diff changeset
  1794
  NoSafepointVerifier nsv;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1795
  ReleaseJavaMonitorsClosure rjmc(THREAD);
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1796
  Thread::muxAcquire(&gListLock, "release_monitors_owned_by_thread");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1797
  ObjectSynchronizer::monitors_iterate(&rjmc);
30244
d4e471395ff5 8073165: Contended Locking fast exit bucket
dcubed
parents: 29070
diff changeset
  1798
  Thread::muxRelease(&gListLock);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents: 5920
diff changeset
  1799
  THREAD->clear_pending_exception();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1802
const char* ObjectSynchronizer::inflate_cause_name(const InflateCause cause) {
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1803
  switch (cause) {
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1804
    case inflate_cause_vm_internal:    return "VM Internal";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1805
    case inflate_cause_monitor_enter:  return "Monitor Enter";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1806
    case inflate_cause_wait:           return "Monitor Wait";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1807
    case inflate_cause_notify:         return "Monitor Notify";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1808
    case inflate_cause_hash_code:      return "Monitor Hash Code";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1809
    case inflate_cause_jni_enter:      return "JNI Monitor Enter";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1810
    case inflate_cause_jni_exit:       return "JNI Monitor Exit";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1811
    default:
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1812
      ShouldNotReachHere();
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1813
  }
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1814
  return "Unknown";
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1815
}
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1816
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1817
static void post_monitor_inflate_event(EventJavaMonitorInflate& event,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1818
                                       const oop obj,
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1819
                                       const ObjectSynchronizer::InflateCause cause) {
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1820
#if INCLUDE_TRACE
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1821
  assert(event.should_commit(), "check outside");
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40655
diff changeset
  1822
  event.set_monitorClass(obj->klass());
35934
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1823
  event.set_address((TYPE_ADDRESS)(uintptr_t)(void*)obj);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1824
  event.set_cause((u1)cause);
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1825
  event.commit();
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1826
#endif
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1827
}
76dbe86f3d82 8138562: Event based tracing should cover monitor inflation
dsimms
parents: 35492
diff changeset
  1828
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
//------------------------------------------------------------------------------
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1830
// Debugging code
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1831
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1832
void ObjectSynchronizer::sanity_checks(const bool verbose,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1833
                                       const uint cache_line_size,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1834
                                       int *error_cnt_ptr,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1835
                                       int *warning_cnt_ptr) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1836
  u_char *addr_begin      = (u_char*)&GVars;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1837
  u_char *addr_stwRandom  = (u_char*)&GVars.stwRandom;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1838
  u_char *addr_hcSequence = (u_char*)&GVars.hcSequence;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1839
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1840
  if (verbose) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1841
    tty->print_cr("INFO: sizeof(SharedGlobals)=" SIZE_FORMAT,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1842
                  sizeof(SharedGlobals));
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1843
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1844
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1845
  uint offset_stwRandom = (uint)(addr_stwRandom - addr_begin);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1846
  if (verbose) tty->print_cr("INFO: offset(stwRandom)=%u", offset_stwRandom);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1847
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1848
  uint offset_hcSequence = (uint)(addr_hcSequence - addr_begin);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1849
  if (verbose) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1850
    tty->print_cr("INFO: offset(_hcSequence)=%u", offset_hcSequence);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1851
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1852
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1853
  if (cache_line_size != 0) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1854
    // We were able to determine the L1 data cache line size so
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1855
    // do some cache line specific sanity checks
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1856
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1857
    if (offset_stwRandom < cache_line_size) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1858
      tty->print_cr("WARNING: the SharedGlobals.stwRandom field is closer "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1859
                    "to the struct beginning than a cache line which permits "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1860
                    "false sharing.");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1861
      (*warning_cnt_ptr)++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1862
    }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1863
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1864
    if ((offset_hcSequence - offset_stwRandom) < cache_line_size) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1865
      tty->print_cr("WARNING: the SharedGlobals.stwRandom and "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1866
                    "SharedGlobals.hcSequence fields are closer than a cache "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1867
                    "line which permits false sharing.");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1868
      (*warning_cnt_ptr)++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1869
    }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1870
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1871
    if ((sizeof(SharedGlobals) - offset_hcSequence) < cache_line_size) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1872
      tty->print_cr("WARNING: the SharedGlobals.hcSequence field is closer "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1873
                    "to the struct end than a cache line which permits false "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1874
                    "sharing.");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1875
      (*warning_cnt_ptr)++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1876
    }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1877
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25477
diff changeset
  1878
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
// Verify all monitors in the monitor cache, the verification is weak.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
void ObjectSynchronizer::verify() {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1884
  PaddedEnd<ObjectMonitor> * block =
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1885
    (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1886
  while (block != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
    assert(block->object() == CHAINMARKER, "must be a block header");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
    for (int i = 1; i < _BLOCKSIZE; i++) {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1889
      ObjectMonitor* mid = (ObjectMonitor *)(block + i);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1890
      oop object = (oop)mid->object();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
      if (object != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
        mid->verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
    }
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1895
    block = (PaddedEnd<ObjectMonitor> *)block->FreeNext;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
// Check if monitor belongs to the monitor cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
// The list is grow-only so it's *relatively* safe to traverse
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
// the list of extant blocks without taking a lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
int ObjectSynchronizer::verify_objmon_isinpool(ObjectMonitor *monitor) {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1904
  PaddedEnd<ObjectMonitor> * block =
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1905
    (PaddedEnd<ObjectMonitor> *)OrderAccess::load_ptr_acquire(&gBlockList);
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1906
  while (block != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
    assert(block->object() == CHAINMARKER, "must be a block header");
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1908
    if (monitor > (ObjectMonitor *)&block[0] &&
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1909
        monitor < (ObjectMonitor *)&block[_BLOCKSIZE]) {
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1910
      address mon = (address)monitor;
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1911
      address blk = (address)block;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
      size_t diff = mon - blk;
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1913
      assert((diff % sizeof(PaddedEnd<ObjectMonitor>)) == 0, "must be aligned");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
      return 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
    }
33595
5830c3ae532d 8047212: runtime/ParallelClassLoading/bootstrap/random/inner-complex assert(ObjectSynchronizer::verify_objmon_isinpool(inf)) failed: monitor is invalid
dcubed
parents: 33148
diff changeset
  1916
    block = (PaddedEnd<ObjectMonitor> *)block->FreeNext;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
#endif