src/hotspot/share/runtime/objectMonitor.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46765 hotspot/src/share/vm/runtime/objectMonitor.cpp@07298ebd9367
child 47634 6a0c42c40cd1
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     1
/*
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46342
diff changeset
     2
 * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     4
 *
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     7
 * published by the Free Software Foundation.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     8
 *
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    13
 * accompanied this code).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    14
 *
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    18
 *
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    21
 * questions.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    22
 *
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    23
 */
dc9b63952682 6988353: refactor contended sync subsystem
acorn
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"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    27
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    28
#include "oops/markOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    29
#include "oops/oop.inline.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 39702
diff changeset
    30
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    31
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    32
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    33
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    34
#include "runtime/objectMonitor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    35
#include "runtime/objectMonitor.inline.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 22881
diff changeset
    36
#include "runtime/orderAccess.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    37
#include "runtime/osThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    38
#include "runtime/stubRoutines.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 13728
diff changeset
    39
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    40
#include "services/threadService.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
    41
#include "trace/tracing.hpp"
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
    42
#include "trace/traceMacros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    43
#include "utilities/dtrace.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
    44
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6975
diff changeset
    45
#include "utilities/preserveException.hpp"
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    46
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    47
#ifdef DTRACE_ENABLED
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    48
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    49
// Only bother with this argument setup if dtrace is available
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    50
// TODO-FIXME: probes should not fire when caller is _blocked.  assert() accordingly.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    51
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    52
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    53
#define DTRACE_MONITOR_PROBE_COMMON(obj, thread)                           \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    54
  char* bytes = NULL;                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    55
  int len = 0;                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    56
  jlong jtid = SharedRuntime::get_java_tid(thread);                        \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    57
  Symbol* klassname = ((oop)obj)->klass()->name();                         \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    58
  if (klassname != NULL) {                                                 \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    59
    bytes = (char*)klassname->bytes();                                     \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    60
    len = klassname->utf8_length();                                        \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    61
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    62
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    63
#define DTRACE_MONITOR_WAIT_PROBE(monitor, obj, thread, millis)            \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    64
  {                                                                        \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    65
    if (DTraceMonitorProbes) {                                             \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    66
      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    67
      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
    68
                           (monitor), bytes, len, (millis));               \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    69
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    70
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    71
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    72
#define HOTSPOT_MONITOR_contended__enter HOTSPOT_MONITOR_CONTENDED_ENTER
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    73
#define HOTSPOT_MONITOR_contended__entered HOTSPOT_MONITOR_CONTENDED_ENTERED
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    74
#define HOTSPOT_MONITOR_contended__exit HOTSPOT_MONITOR_CONTENDED_EXIT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    75
#define HOTSPOT_MONITOR_notify HOTSPOT_MONITOR_NOTIFY
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    76
#define HOTSPOT_MONITOR_notifyAll HOTSPOT_MONITOR_NOTIFYALL
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    77
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    78
#define DTRACE_MONITOR_PROBE(probe, monitor, obj, thread)                  \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    79
  {                                                                        \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    80
    if (DTraceMonitorProbes) {                                             \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    81
      DTRACE_MONITOR_PROBE_COMMON(obj, thread);                            \
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    82
      HOTSPOT_MONITOR_##probe(jtid,                                        \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
    83
                              (uintptr_t)(monitor), bytes, len);           \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    84
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    85
  }
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
    86
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    87
#else //  ndef DTRACE_ENABLED
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    88
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 10739
diff changeset
    89
#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
    90
#define DTRACE_MONITOR_PROBE(probe, obj, thread, mon)          {;}
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    91
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    92
#endif // ndef DTRACE_ENABLED
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    93
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    94
// Tunables ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    95
// The knob* variables are effectively final.  Once set they should
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    96
// never be modified hence.  Consider using __read_mostly with GCC.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
    97
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
    98
int ObjectMonitor::Knob_ExitRelease = 0;
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
    99
int ObjectMonitor::Knob_Verbose     = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   100
int ObjectMonitor::Knob_VerifyInUse = 0;
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
   101
int ObjectMonitor::Knob_VerifyMatch = 0;
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   102
int ObjectMonitor::Knob_SpinLimit   = 5000;    // derived by an external tool -
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   103
static int Knob_LogSpins            = 0;       // enable jvmstat tally for spins
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   104
static int Knob_HandOff             = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   105
static int Knob_ReportSettings      = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   106
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   107
static int Knob_SpinBase            = 0;       // Floor AKA SpinMin
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   108
static int Knob_SpinBackOff         = 0;       // spin-loop backoff
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   109
static int Knob_CASPenalty          = -1;      // Penalty for failed CAS
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   110
static int Knob_OXPenalty           = -1;      // Penalty for observed _owner change
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   111
static int Knob_SpinSetSucc         = 1;       // spinners set the _succ field
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   112
static int Knob_SpinEarly           = 1;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   113
static int Knob_SuccEnabled         = 1;       // futile wake throttling
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   114
static int Knob_SuccRestrict        = 0;       // Limit successors + spinners to at-most-one
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   115
static int Knob_MaxSpinners         = -1;      // Should be a function of # CPUs
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   116
static int Knob_Bonus               = 100;     // spin success bonus
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   117
static int Knob_BonusB              = 100;     // spin success bonus
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   118
static int Knob_Penalty             = 200;     // spin failure penalty
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   119
static int Knob_Poverty             = 1000;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   120
static int Knob_SpinAfterFutile     = 1;       // Spin after returning from park()
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   121
static int Knob_FixedSpin           = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   122
static int Knob_OState              = 3;       // Spinner checks thread state of _owner
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   123
static int Knob_UsePause            = 1;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   124
static int Knob_ExitPolicy          = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   125
static int Knob_PreSpin             = 10;      // 20-100 likely better
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   126
static int Knob_ResetEvent          = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   127
static int BackOffMask              = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   128
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   129
static int Knob_FastHSSEC           = 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   130
static int Knob_MoveNotifyee        = 2;       // notify() - disposition of notifyee
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   131
static int Knob_QMode               = 0;       // EntryList-cxq policy - queue discipline
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   132
static volatile int InitDone        = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   133
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   134
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   135
// Theory of operations -- Monitors lists, thread residency, etc:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   136
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   137
// * A thread acquires ownership of a monitor by successfully
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   138
//   CAS()ing the _owner field from null to non-null.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   139
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   140
// * Invariant: A thread appears on at most one monitor list --
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   141
//   cxq, EntryList or WaitSet -- at any one time.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   142
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   143
// * Contending threads "push" themselves onto the cxq with CAS
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   144
//   and then spin/park.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   145
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   146
// * After a contending thread eventually acquires the lock it must
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   147
//   dequeue itself from either the EntryList or the cxq.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   148
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   149
// * The exiting thread identifies and unparks an "heir presumptive"
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   150
//   tentative successor thread on the EntryList.  Critically, the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   151
//   exiting thread doesn't unlink the successor thread from the EntryList.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   152
//   After having been unparked, the wakee will recontend for ownership of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   153
//   the monitor.   The successor (wakee) will either acquire the lock or
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   154
//   re-park itself.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   155
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   156
//   Succession is provided for by a policy of competitive handoff.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   157
//   The exiting thread does _not_ grant or pass ownership to the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   158
//   successor thread.  (This is also referred to as "handoff" succession").
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   159
//   Instead the exiting thread releases ownership and possibly wakes
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   160
//   a successor, so the successor can (re)compete for ownership of the lock.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   161
//   If the EntryList is empty but the cxq is populated the exiting
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   162
//   thread will drain the cxq into the EntryList.  It does so by
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   163
//   by detaching the cxq (installing null with CAS) and folding
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   164
//   the threads from the cxq into the EntryList.  The EntryList is
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   165
//   doubly linked, while the cxq is singly linked because of the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   166
//   CAS-based "push" used to enqueue recently arrived threads (RATs).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   167
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   168
// * Concurrency invariants:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   169
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   170
//   -- only the monitor owner may access or mutate the EntryList.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   171
//      The mutex property of the monitor itself protects the EntryList
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   172
//      from concurrent interference.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   173
//   -- Only the monitor owner may detach the cxq.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   174
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   175
// * The monitor entry list operations avoid locks, but strictly speaking
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   176
//   they're not lock-free.  Enter is lock-free, exit is not.
32622
7ed47d0b888a 8135002: Fix or remove broken links in objectMonitor.cpp comments
dbuck
parents: 32614
diff changeset
   177
//   For a description of 'Methods and apparatus providing non-blocking access
7ed47d0b888a 8135002: Fix or remove broken links in objectMonitor.cpp comments
dbuck
parents: 32614
diff changeset
   178
//   to a resource,' see U.S. Pat. No. 7844973.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   179
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   180
// * The cxq can have multiple concurrent "pushers" but only one concurrent
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   181
//   detaching thread.  This mechanism is immune from the ABA corruption.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   182
//   More precisely, the CAS-based "push" onto cxq is ABA-oblivious.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   183
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   184
// * Taken together, the cxq and the EntryList constitute or form a
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   185
//   single logical queue of threads stalled trying to acquire the lock.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   186
//   We use two distinct lists to improve the odds of a constant-time
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18025
diff changeset
   187
//   dequeue operation after acquisition (in the ::enter() epilogue) and
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   188
//   to reduce heat on the list ends.  (c.f. Michael Scott's "2Q" algorithm).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   189
//   A key desideratum is to minimize queue & monitor metadata manipulation
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   190
//   that occurs while holding the monitor lock -- that is, we want to
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   191
//   minimize monitor lock holds times.  Note that even a small amount of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   192
//   fixed spinning will greatly reduce the # of enqueue-dequeue operations
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   193
//   on EntryList|cxq.  That is, spinning relieves contention on the "inner"
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   194
//   locks and monitor metadata.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   195
//
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   196
//   Cxq points to the set of Recently Arrived Threads attempting entry.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   197
//   Because we push threads onto _cxq with CAS, the RATs must take the form of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   198
//   a singly-linked LIFO.  We drain _cxq into EntryList  at unlock-time when
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   199
//   the unlocking thread notices that EntryList is null but _cxq is != null.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   200
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   201
//   The EntryList is ordered by the prevailing queue discipline and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   202
//   can be organized in any convenient fashion, such as a doubly-linked list or
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   203
//   a circular doubly-linked list.  Critically, we want insert and delete operations
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   204
//   to operate in constant-time.  If we need a priority queue then something akin
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   205
//   to Solaris' sleepq would work nicely.  Viz.,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   206
//   http://agg.eng/ws/on10_nightly/source/usr/src/uts/common/os/sleepq.c.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   207
//   Queue discipline is enforced at ::exit() time, when the unlocking thread
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   208
//   drains the cxq into the EntryList, and orders or reorders the threads on the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   209
//   EntryList accordingly.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   210
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   211
//   Barring "lock barging", this mechanism provides fair cyclic ordering,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   212
//   somewhat similar to an elevator-scan.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   213
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   214
// * The monitor synchronization subsystem avoids the use of native
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   215
//   synchronization primitives except for the narrow platform-specific
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   216
//   park-unpark abstraction.  See the comments in os_solaris.cpp regarding
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   217
//   the semantics of park-unpark.  Put another way, this monitor implementation
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   218
//   depends only on atomic operations and park-unpark.  The monitor subsystem
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   219
//   manages all RUNNING->BLOCKED and BLOCKED->READY transitions while the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   220
//   underlying OS manages the READY<->RUN transitions.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   221
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   222
// * Waiting threads reside on the WaitSet list -- wait() puts
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   223
//   the caller onto the WaitSet.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   224
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   225
// * notify() or notifyAll() simply transfers threads from the WaitSet to
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   226
//   either the EntryList or cxq.  Subsequent exit() operations will
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   227
//   unpark the notifyee.  Unparking a notifee in notify() is inefficient -
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   228
//   it's likely the notifyee would simply impale itself on the lock held
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   229
//   by the notifier.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   230
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   231
// * An interesting alternative is to encode cxq as (List,LockByte) where
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   232
//   the LockByte is 0 iff the monitor is owned.  _owner is simply an auxiliary
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   233
//   variable, like _recursions, in the scheme.  The threads or Events that form
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   234
//   the list would have to be aligned in 256-byte addresses.  A thread would
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   235
//   try to acquire the lock or enqueue itself with CAS, but exiting threads
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   236
//   could use a 1-0 protocol and simply STB to set the LockByte to 0.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   237
//   Note that is is *not* word-tearing, but it does presume that full-word
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   238
//   CAS operations are coherent with intermix with STB operations.  That's true
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   239
//   on most common processors.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   240
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   241
// * See also http://blogs.sun.com/dave
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   242
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   243
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   244
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   245
// Enter support
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   246
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 36384
diff changeset
   247
void ObjectMonitor::enter(TRAPS) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   248
  // The following code is ordered to check the most common cases first
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   249
  // and to reduce RTS->RTO cache line upgrades on SPARC and IA32 processors.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   250
  Thread * const Self = THREAD;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   251
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   252
  void * cur = Atomic::cmpxchg_ptr (Self, &_owner, NULL);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   253
  if (cur == NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   254
    // Either ASSERT _recursions == 0 or explicitly set _recursions = 0.
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   255
    assert(_recursions == 0, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   256
    assert(_owner == Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   257
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   258
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   259
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   260
  if (cur == Self) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   261
    // TODO-FIXME: check for integer overflow!  BUGID 6557169.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   262
    _recursions++;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   263
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   264
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   265
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   266
  if (Self->is_lock_owned ((address)cur)) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   267
    assert(_recursions == 0, "internal state error");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   268
    _recursions = 1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   269
    // Commute owner from a thread-specific on-stack BasicLockObject address to
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   270
    // a full-fledged "Thread *".
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   271
    _owner = Self;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   272
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   273
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   274
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   275
  // We've encountered genuine contention.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   276
  assert(Self->_Stalled == 0, "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   277
  Self->_Stalled = intptr_t(this);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   278
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   279
  // Try one round of spinning *before* enqueueing Self
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   280
  // and before going through the awkward and expensive state
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   281
  // transitions.  The following spin is strictly optional ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   282
  // Note that if we acquire the monitor from an initial spin
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   283
  // we forgo posting JVMTI events and firing DTRACE probes.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   284
  if (Knob_SpinEarly && TrySpin (Self) > 0) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   285
    assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   286
    assert(_recursions == 0, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   287
    assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   288
    Self->_Stalled = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   289
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   290
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   291
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   292
  assert(_owner != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   293
  assert(_succ != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   294
  assert(Self->is_Java_thread(), "invariant");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   295
  JavaThread * jt = (JavaThread *) Self;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   296
  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
   297
  assert(jt->thread_state() != _thread_blocked, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   298
  assert(this->object() != NULL, "invariant");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   299
  assert(_count >= 0, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   300
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   301
  // Prevent deflation at STW-time.  See deflate_idle_monitors() and is_busy().
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   302
  // Ensure the object-monitor relationship remains stable while there's contention.
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   303
  Atomic::inc(&_count);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   304
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   305
  EventJavaMonitorEnter event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   306
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   307
  { // Change java thread status to indicate blocked on monitor enter.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   308
    JavaThreadBlockedOnMonitorEnterState jtbmes(jt, this);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   309
46765
07298ebd9367 8185164: GetOwnedMonitorInfo() returns incorrect owned monitor
ysuenaga
parents: 46630
diff changeset
   310
    Self->set_current_pending_monitor(this);
07298ebd9367 8185164: GetOwnedMonitorInfo() returns incorrect owned monitor
ysuenaga
parents: 46630
diff changeset
   311
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   312
    DTRACE_MONITOR_PROBE(contended__enter, this, object(), jt);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   313
    if (JvmtiExport::should_post_monitor_contended_enter()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   314
      JvmtiExport::post_monitor_contended_enter(jt, this);
22753
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   315
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   316
      // The current thread does not yet own the monitor and does not
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   317
      // yet appear on any queues that would get it made the successor.
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   318
      // This means that the JVMTI_EVENT_MONITOR_CONTENDED_ENTER event
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   319
      // handler cannot accidentally consume an unpark() meant for the
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   320
      // ParkEvent associated with this ObjectMonitor.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   321
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   322
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   323
    OSThreadContendState osts(Self->osthread());
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   324
    ThreadBlockInVM tbivm(jt);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   325
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   326
    // TODO-FIXME: change the following for(;;) loop to straight-line code.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   327
    for (;;) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   328
      jt->set_suspend_equivalent();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   329
      // cleared by handle_special_suspend_equivalent_condition()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   330
      // or java_suspend_self()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   331
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   332
      EnterI(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   333
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   334
      if (!ExitSuspendEquivalent(jt)) break;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   335
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   336
      // We have acquired the contended monitor, but while we were
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   337
      // waiting another thread suspended us. We don't want to enter
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   338
      // the monitor while suspended because that would surprise the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   339
      // thread that suspended us.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   340
      //
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   341
      _recursions = 0;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   342
      _succ = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   343
      exit(false, Self);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   344
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   345
      jt->java_suspend_self();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   346
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   347
    Self->set_current_pending_monitor(NULL);
24832
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   348
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   349
    // We cleared the pending monitor info since we've just gotten past
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   350
    // the enter-check-for-suspend dance and we now own the monitor free
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   351
    // and clear, i.e., it is no longer pending. The ThreadBlockInVM
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   352
    // destructor can go to a safepoint at the end of this block. If we
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   353
    // do a thread dump during that safepoint, then this thread will show
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   354
    // as having "-locked" the monitor, but the OS and java.lang.Thread
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   355
    // states will still report that the thread is blocked trying to
26a834fb508d 8036823: Stack trace sometimes shows 'locked' instead of 'waiting to lock'
dcubed
parents: 24351
diff changeset
   356
    // acquire it.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   357
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   358
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
   359
  Atomic::dec(&_count);
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   360
  assert(_count >= 0, "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   361
  Self->_Stalled = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   362
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   363
  // Must either set _recursions = 0 or ASSERT _recursions == 0.
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   364
  assert(_recursions == 0, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   365
  assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   366
  assert(_succ != Self, "invariant");
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   367
  assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   368
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   369
  // The thread -- now the owner -- is back in vm mode.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   370
  // Report the glorious news via TI,DTrace and jvmstat.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   371
  // The probe effect is non-trivial.  All the reportage occurs
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   372
  // while we hold the monitor, increasing the length of the critical
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   373
  // section.  Amdahl's parallel speedup law comes vividly into play.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   374
  //
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   375
  // Another option might be to aggregate the events (thread local or
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   376
  // per-monitor aggregation) and defer reporting until a more opportune
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   377
  // time -- such as next time some thread encounters contention but has
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   378
  // yet to acquire the lock.  While spinning that thread could
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   379
  // spinning we could increment JVMStat counters, etc.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   380
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   381
  DTRACE_MONITOR_PROBE(contended__entered, this, object(), jt);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   382
  if (JvmtiExport::should_post_monitor_contended_entered()) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   383
    JvmtiExport::post_monitor_contended_entered(jt, this);
22753
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   384
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   385
    // The current thread already owns the monitor and is not going to
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   386
    // call park() for the remainder of the monitor enter protocol. So
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   387
    // it doesn't matter if the JVMTI_EVENT_MONITOR_CONTENDED_ENTERED
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   388
    // event handler consumed an unpark() issued by the thread that
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
   389
    // just exited the monitor.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   390
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   391
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   392
  if (event.should_commit()) {
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40655
diff changeset
   393
    event.set_monitorClass(((oop)this->object())->klass());
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
   394
    event.set_previousOwner((TYPE_THREAD)_previous_owner_tid);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   395
    event.set_address((TYPE_ADDRESS)(uintptr_t)(this->object_addr()));
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   396
    event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   397
  }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   398
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   399
  OM_PERFDATA_OP(ContendedLockAttempts, inc());
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   400
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   401
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   402
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   403
// Caveat: TryLock() is not necessarily serializing if it returns failure.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   404
// Callers must compensate as needed.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   405
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   406
int ObjectMonitor::TryLock(Thread * Self) {
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   407
  void * own = _owner;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   408
  if (own != NULL) return 0;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   409
  if (Atomic::cmpxchg_ptr (Self, &_owner, NULL) == NULL) {
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   410
    // Either guarantee _recursions == 0 or set _recursions = 0.
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   411
    assert(_recursions == 0, "invariant");
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   412
    assert(_owner == Self, "invariant");
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   413
    return 1;
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   414
  }
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   415
  // The lock had been free momentarily, but we lost the race to the lock.
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   416
  // Interference -- the CAS failed.
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   417
  // We can either return -1 or retry.
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   418
  // Retry doesn't make as much sense because the lock was just acquired.
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   419
  return -1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   420
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   421
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   422
#define MAX_RECHECK_INTERVAL 1000
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   423
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 36384
diff changeset
   424
void ObjectMonitor::EnterI(TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   425
  Thread * const Self = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   426
  assert(Self->is_Java_thread(), "invariant");
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   427
  assert(((JavaThread *) Self)->thread_state() == _thread_blocked, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   428
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   429
  // Try the lock - TATAS
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   430
  if (TryLock (Self) > 0) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   431
    assert(_succ != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   432
    assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   433
    assert(_Responsible != Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   434
    return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   435
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   436
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   437
  DeferredInitialize();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   438
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   439
  // We try one round of spinning *before* enqueueing Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   440
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   441
  // If the _owner is ready but OFFPROC we could use a YieldTo()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   442
  // operation to donate the remainder of this thread's quantum
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   443
  // to the owner.  This has subtle but beneficial affinity
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   444
  // effects.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   445
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   446
  if (TrySpin (Self) > 0) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   447
    assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   448
    assert(_succ != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   449
    assert(_Responsible != Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   450
    return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   451
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   452
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   453
  // The Spin failed -- Enqueue and park the thread ...
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   454
  assert(_succ != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   455
  assert(_owner != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   456
  assert(_Responsible != Self, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   457
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   458
  // Enqueue "Self" on ObjectMonitor's _cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   459
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   460
  // Node acts as a proxy for Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   461
  // As an aside, if were to ever rewrite the synchronization code mostly
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   462
  // in Java, WaitNodes, ObjectMonitors, and Events would become 1st-class
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   463
  // Java objects.  This would avoid awkward lifecycle and liveness issues,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   464
  // as well as eliminate a subset of ABA issues.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   465
  // TODO: eliminate ObjectWaiter and enqueue either Threads or Events.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   466
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   467
  ObjectWaiter node(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   468
  Self->_ParkEvent->reset();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   469
  node._prev   = (ObjectWaiter *) 0xBAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   470
  node.TState  = ObjectWaiter::TS_CXQ;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   471
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   472
  // Push "Self" onto the front of the _cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   473
  // Once on cxq/EntryList, Self stays on-queue until it acquires the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   474
  // Note that spinning tends to reduce the rate at which threads
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   475
  // enqueue and dequeue on EntryList|cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   476
  ObjectWaiter * nxt;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   477
  for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   478
    node._next = nxt = _cxq;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   479
    if (Atomic::cmpxchg_ptr(&node, &_cxq, nxt) == nxt) break;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   480
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   481
    // Interference - the CAS failed because _cxq changed.  Just retry.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   482
    // As an optional optimization we retry the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   483
    if (TryLock (Self) > 0) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   484
      assert(_succ != Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   485
      assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   486
      assert(_Responsible != Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   487
      return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   488
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   489
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   490
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   491
  // Check for cxq|EntryList edge transition to non-null.  This indicates
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   492
  // the onset of contention.  While contention persists exiting threads
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   493
  // will use a ST:MEMBAR:LD 1-1 exit protocol.  When contention abates exit
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   494
  // operations revert to the faster 1-0 mode.  This enter operation may interleave
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   495
  // (race) a concurrent 1-0 exit operation, resulting in stranding, so we
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   496
  // arrange for one of the contending thread to use a timed park() operations
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   497
  // to detect and recover from the race.  (Stranding is form of progress failure
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   498
  // where the monitor is unlocked but all the contending threads remain parked).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   499
  // That is, at least one of the contended threads will periodically poll _owner.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   500
  // One of the contending threads will become the designated "Responsible" thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   501
  // The Responsible thread uses a timed park instead of a normal indefinite park
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   502
  // operation -- it periodically wakes and checks for and recovers from potential
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   503
  // strandings admitted by 1-0 exit operations.   We need at most one Responsible
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   504
  // thread per-monitor at any given moment.  Only threads on cxq|EntryList may
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   505
  // be responsible for a monitor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   506
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   507
  // Currently, one of the contended threads takes on the added role of "Responsible".
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   508
  // A viable alternative would be to use a dedicated "stranding checker" thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   509
  // that periodically iterated over all the threads (or active monitors) and unparked
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   510
  // successors where there was risk of stranding.  This would help eliminate the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   511
  // timer scalability issues we see on some platforms as we'd only have one thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   512
  // -- the checker -- parked on a timer.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   513
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   514
  if ((SyncFlags & 16) == 0 && nxt == NULL && _EntryList == NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   515
    // Try to assume the role of responsible thread for the monitor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   516
    // CONSIDER:  ST vs CAS vs { if (Responsible==null) Responsible=Self }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   517
    Atomic::cmpxchg_ptr(Self, &_Responsible, NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   518
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   519
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   520
  // The lock might have been released while this thread was occupied queueing
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   521
  // itself onto _cxq.  To close the race and avoid "stranding" and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   522
  // progress-liveness failure we must resample-retry _owner before parking.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   523
  // Note the Dekker/Lamport duality: ST cxq; MEMBAR; LD Owner.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   524
  // In this case the ST-MEMBAR is accomplished with CAS().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   525
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   526
  // TODO: Defer all thread state transitions until park-time.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   527
  // Since state transitions are heavy and inefficient we'd like
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   528
  // to defer the state transitions until absolutely necessary,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   529
  // and in doing so avoid some transitions ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   530
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   531
  TEVENT(Inflated enter - Contention);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   532
  int nWakeups = 0;
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   533
  int recheckInterval = 1;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   534
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   535
  for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   536
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   537
    if (TryLock(Self) > 0) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   538
    assert(_owner != Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   539
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   540
    if ((SyncFlags & 2) && _Responsible == NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   541
      Atomic::cmpxchg_ptr(Self, &_Responsible, NULL);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   542
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   543
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   544
    // park self
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   545
    if (_Responsible == Self || (SyncFlags & 1)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   546
      TEVENT(Inflated enter - park TIMED);
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   547
      Self->_ParkEvent->park((jlong) recheckInterval);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   548
      // Increase the recheckInterval, but clamp the value.
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   549
      recheckInterval *= 8;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   550
      if (recheckInterval > MAX_RECHECK_INTERVAL) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   551
        recheckInterval = MAX_RECHECK_INTERVAL;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   552
      }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   553
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   554
      TEVENT(Inflated enter - park UNTIMED);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   555
      Self->_ParkEvent->park();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   556
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   557
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   558
    if (TryLock(Self) > 0) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   559
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   560
    // The lock is still contested.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   561
    // Keep a tally of the # of futile wakeups.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   562
    // Note that the counter is not protected by a lock or updated by atomics.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   563
    // That is by design - we trade "lossy" counters which are exposed to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   564
    // races during updates for a lower probe effect.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   565
    TEVENT(Inflated enter - Futile wakeup);
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   566
    // This PerfData object can be used in parallel with a safepoint.
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   567
    // See the work around in PerfDataManager::destroy().
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   568
    OM_PERFDATA_OP(FutileWakeups, inc());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   569
    ++nWakeups;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   570
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   571
    // Assuming this is not a spurious wakeup we'll normally find _succ == Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   572
    // We can defer clearing _succ until after the spin completes
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   573
    // TrySpin() must tolerate being called with _succ == Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   574
    // Try yet another round of adaptive spinning.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   575
    if ((Knob_SpinAfterFutile & 1) && TrySpin(Self) > 0) break;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   576
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   577
    // We can find that we were unpark()ed and redesignated _succ while
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   578
    // we were spinning.  That's harmless.  If we iterate and call park(),
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   579
    // park() will consume the event and return immediately and we'll
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   580
    // just spin again.  This pattern can repeat, leaving _succ to simply
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   581
    // spin on a CPU.  Enable Knob_ResetEvent to clear pending unparks().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   582
    // Alternately, we can sample fired() here, and if set, forgo spinning
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   583
    // in the next iteration.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   584
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   585
    if ((Knob_ResetEvent & 1) && Self->_ParkEvent->fired()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   586
      Self->_ParkEvent->reset();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   587
      OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   588
    }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
   589
    if (_succ == Self) _succ = NULL;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   590
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   591
    // Invariant: after clearing _succ a thread *must* retry _owner before parking.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   592
    OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   593
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   594
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   595
  // Egress :
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   596
  // Self has acquired the lock -- Unlink Self from the cxq or EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   597
  // Normally we'll find Self on the EntryList .
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   598
  // From the perspective of the lock owner (this thread), the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   599
  // EntryList is stable and cxq is prepend-only.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   600
  // The head of cxq is volatile but the interior is stable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   601
  // In addition, Self.TState is stable.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   602
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   603
  assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   604
  assert(object() != NULL, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   605
  // I'd like to write:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   606
  //   guarantee (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   607
  // but as we're at a safepoint that's not safe.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   608
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   609
  UnlinkAfterAcquire(Self, &node);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   610
  if (_succ == Self) _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   611
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   612
  assert(_succ != Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   613
  if (_Responsible == Self) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   614
    _Responsible = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   615
    OrderAccess::fence(); // Dekker pivot-point
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   616
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   617
    // We may leave threads on cxq|EntryList without a designated
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   618
    // "Responsible" thread.  This is benign.  When this thread subsequently
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   619
    // exits the monitor it can "see" such preexisting "old" threads --
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   620
    // threads that arrived on the cxq|EntryList before the fence, above --
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   621
    // by LDing cxq|EntryList.  Newly arrived threads -- that is, threads
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   622
    // that arrive on cxq after the ST:MEMBAR, above -- will set Responsible
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   623
    // non-null and elect a new "Responsible" timer thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   624
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   625
    // This thread executes:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   626
    //    ST Responsible=null; MEMBAR    (in enter epilogue - here)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   627
    //    LD cxq|EntryList               (in subsequent exit)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   628
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   629
    // Entering threads in the slow/contended path execute:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   630
    //    ST cxq=nonnull; MEMBAR; LD Responsible (in enter prolog)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   631
    //    The (ST cxq; MEMBAR) is accomplished with CAS().
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   632
    //
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   633
    // The MEMBAR, above, prevents the LD of cxq|EntryList in the subsequent
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   634
    // exit operation from floating above the ST Responsible=null.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   635
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   636
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   637
  // We've acquired ownership with CAS().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   638
  // CAS is serializing -- it has MEMBAR/FENCE-equivalent semantics.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   639
  // But since the CAS() this thread may have also stored into _succ,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   640
  // EntryList, cxq or Responsible.  These meta-data updates must be
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   641
  // visible __before this thread subsequently drops the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   642
  // Consider what could occur if we didn't enforce this constraint --
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   643
  // STs to monitor meta-data and user-data could reorder with (become
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   644
  // visible after) the ST in exit that drops ownership of the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   645
  // Some other thread could then acquire the lock, but observe inconsistent
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   646
  // or old monitor meta-data and heap data.  That violates the JMM.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   647
  // To that end, the 1-0 exit() operation must have at least STST|LDST
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   648
  // "release" barrier semantics.  Specifically, there must be at least a
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   649
  // STST|LDST barrier in exit() before the ST of null into _owner that drops
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   650
  // the lock.   The barrier ensures that changes to monitor meta-data and data
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   651
  // protected by the lock will be visible before we release the lock, and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   652
  // therefore before some other thread (CPU) has a chance to acquire the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   653
  // See also: http://gee.cs.oswego.edu/dl/jmm/cookbook.html.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   654
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   655
  // Critically, any prior STs to _succ or EntryList must be visible before
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   656
  // the ST of null into _owner in the *subsequent* (following) corresponding
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   657
  // monitorexit.  Recall too, that in 1-0 mode monitorexit does not necessarily
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   658
  // execute a serializing instruction.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   659
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   660
  if (SyncFlags & 8) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   661
    OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   662
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   663
  return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   664
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   665
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   666
// ReenterI() is a specialized inline form of the latter half of the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   667
// contended slow-path from EnterI().  We use ReenterI() only for
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   668
// monitor reentry in wait().
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   669
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   670
// In the future we should reconcile EnterI() and ReenterI(), adding
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   671
// Knob_Reset and Knob_SpinAfterFutile support and restructuring the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   672
// loop accordingly.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   673
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 36384
diff changeset
   674
void ObjectMonitor::ReenterI(Thread * Self, ObjectWaiter * SelfNode) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   675
  assert(Self != NULL, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   676
  assert(SelfNode != NULL, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   677
  assert(SelfNode->_thread == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   678
  assert(_waiters > 0, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   679
  assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   680
  assert(((JavaThread *)Self)->thread_state() != _thread_blocked, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   681
  JavaThread * jt = (JavaThread *) Self;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   682
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   683
  int nWakeups = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   684
  for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   685
    ObjectWaiter::TStates v = SelfNode->TState;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   686
    guarantee(v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   687
    assert(_owner != Self, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   688
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   689
    if (TryLock(Self) > 0) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   690
    if (TrySpin(Self) > 0) break;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   691
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   692
    TEVENT(Wait Reentry - parking);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   693
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   694
    // State transition wrappers around park() ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   695
    // ReenterI() wisely defers state transitions until
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   696
    // it's clear we must park the thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   697
    {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   698
      OSThreadContendState osts(Self->osthread());
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   699
      ThreadBlockInVM tbivm(jt);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   700
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   701
      // cleared by handle_special_suspend_equivalent_condition()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   702
      // or java_suspend_self()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   703
      jt->set_suspend_equivalent();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   704
      if (SyncFlags & 1) {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
   705
        Self->_ParkEvent->park((jlong)MAX_RECHECK_INTERVAL);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   706
      } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   707
        Self->_ParkEvent->park();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   708
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   709
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   710
      // were we externally suspended while we were waiting?
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   711
      for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   712
        if (!ExitSuspendEquivalent(jt)) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   713
        if (_succ == Self) { _succ = NULL; OrderAccess::fence(); }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   714
        jt->java_suspend_self();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   715
        jt->set_suspend_equivalent();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   716
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   717
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   718
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   719
    // Try again, but just so we distinguish between futile wakeups and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   720
    // successful wakeups.  The following test isn't algorithmically
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   721
    // necessary, but it helps us maintain sensible statistics.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   722
    if (TryLock(Self) > 0) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   723
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   724
    // The lock is still contested.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   725
    // Keep a tally of the # of futile wakeups.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   726
    // Note that the counter is not protected by a lock or updated by atomics.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   727
    // That is by design - we trade "lossy" counters which are exposed to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   728
    // races during updates for a lower probe effect.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   729
    TEVENT(Wait Reentry - futile wakeup);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   730
    ++nWakeups;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   731
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   732
    // Assuming this is not a spurious wakeup we'll normally
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   733
    // find that _succ == Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   734
    if (_succ == Self) _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   735
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   736
    // Invariant: after clearing _succ a contending thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   737
    // *must* retry  _owner before parking.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   738
    OrderAccess::fence();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   739
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   740
    // This PerfData object can be used in parallel with a safepoint.
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   741
    // See the work around in PerfDataManager::destroy().
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
   742
    OM_PERFDATA_OP(FutileWakeups, inc());
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   743
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   744
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   745
  // Self has acquired the lock -- Unlink Self from the cxq or EntryList .
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   746
  // Normally we'll find Self on the EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   747
  // Unlinking from the EntryList is constant-time and atomic-free.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   748
  // From the perspective of the lock owner (this thread), the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   749
  // EntryList is stable and cxq is prepend-only.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   750
  // The head of cxq is volatile but the interior is stable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   751
  // In addition, Self.TState is stable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   752
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   753
  assert(_owner == Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   754
  assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   755
  UnlinkAfterAcquire(Self, SelfNode);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   756
  if (_succ == Self) _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   757
  assert(_succ != Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   758
  SelfNode->TState = ObjectWaiter::TS_RUN;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   759
  OrderAccess::fence();      // see comments at the end of EnterI()
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   760
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   761
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   762
// By convention we unlink a contending thread from EntryList|cxq immediately
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   763
// after the thread acquires the lock in ::enter().  Equally, we could defer
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   764
// unlinking the thread until ::exit()-time.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   765
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   766
void ObjectMonitor::UnlinkAfterAcquire(Thread *Self, ObjectWaiter *SelfNode) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   767
  assert(_owner == Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   768
  assert(SelfNode->_thread == Self, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   769
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   770
  if (SelfNode->TState == ObjectWaiter::TS_ENTER) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   771
    // Normal case: remove Self from the DLL EntryList .
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   772
    // This is a constant-time operation.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   773
    ObjectWaiter * nxt = SelfNode->_next;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   774
    ObjectWaiter * prv = SelfNode->_prev;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   775
    if (nxt != NULL) nxt->_prev = prv;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   776
    if (prv != NULL) prv->_next = nxt;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   777
    if (SelfNode == _EntryList) _EntryList = nxt;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   778
    assert(nxt == NULL || nxt->TState == ObjectWaiter::TS_ENTER, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   779
    assert(prv == NULL || prv->TState == ObjectWaiter::TS_ENTER, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   780
    TEVENT(Unlink from EntryList);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   781
  } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   782
    assert(SelfNode->TState == ObjectWaiter::TS_CXQ, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   783
    // Inopportune interleaving -- Self is still on the cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   784
    // This usually means the enqueue of self raced an exiting thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   785
    // Normally we'll find Self near the front of the cxq, so
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   786
    // dequeueing is typically fast.  If needbe we can accelerate
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   787
    // this with some MCS/CHL-like bidirectional list hints and advisory
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   788
    // back-links so dequeueing from the interior will normally operate
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   789
    // in constant-time.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   790
    // Dequeue Self from either the head (with CAS) or from the interior
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   791
    // with a linear-time scan and normal non-atomic memory operations.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   792
    // CONSIDER: if Self is on the cxq then simply drain cxq into EntryList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   793
    // and then unlink Self from EntryList.  We have to drain eventually,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   794
    // so it might as well be now.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   795
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   796
    ObjectWaiter * v = _cxq;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   797
    assert(v != NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   798
    if (v != SelfNode || Atomic::cmpxchg_ptr (SelfNode->_next, &_cxq, v) != v) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   799
      // The CAS above can fail from interference IFF a "RAT" arrived.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   800
      // In that case Self must be in the interior and can no longer be
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   801
      // at the head of cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   802
      if (v == SelfNode) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   803
        assert(_cxq != v, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   804
        v = _cxq;          // CAS above failed - start scan at head of list
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   805
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   806
      ObjectWaiter * p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   807
      ObjectWaiter * q = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   808
      for (p = v; p != NULL && p != SelfNode; p = p->_next) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   809
        q = p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   810
        assert(p->TState == ObjectWaiter::TS_CXQ, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   811
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   812
      assert(v != SelfNode, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   813
      assert(p == SelfNode, "Node not found on cxq");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   814
      assert(p != _cxq, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   815
      assert(q != NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   816
      assert(q->_next == p, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   817
      q->_next = p->_next;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   818
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   819
    TEVENT(Unlink from cxq);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   820
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   821
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   822
#ifdef ASSERT
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   823
  // Diagnostic hygiene ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   824
  SelfNode->_prev  = (ObjectWaiter *) 0xBAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   825
  SelfNode->_next  = (ObjectWaiter *) 0xBAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   826
  SelfNode->TState = ObjectWaiter::TS_RUN;
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   827
#endif
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   828
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   829
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   830
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   831
// Exit support
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   832
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   833
// exit()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   834
// ~~~~~~
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   835
// Note that the collector can't reclaim the objectMonitor or deflate
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   836
// the object out from underneath the thread calling ::exit() as the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   837
// thread calling ::exit() never transitions to a stable state.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   838
// This inhibits GC, which in turn inhibits asynchronous (and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   839
// inopportune) reclamation of "this".
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   840
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   841
// We'd like to assert that: (THREAD->thread_state() != _thread_blocked) ;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   842
// There's one exception to the claim above, however.  EnterI() can call
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   843
// exit() to drop a lock if the acquirer has been externally suspended.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   844
// In that case exit() is called with _thread_state as _thread_blocked,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   845
// but the monitor's _count field is > 0, which inhibits reclamation.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   846
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   847
// 1-0 exit
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   848
// ~~~~~~~~
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   849
// ::exit() uses a canonical 1-1 idiom with a MEMBAR although some of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   850
// the fast-path operators have been optimized so the common ::exit()
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37092
diff changeset
   851
// operation is 1-0, e.g., see macroAssembler_x86.cpp: fast_unlock().
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   852
// The code emitted by fast_unlock() elides the usual MEMBAR.  This
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   853
// greatly improves latency -- MEMBAR and CAS having considerable local
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   854
// latency on modern processors -- but at the cost of "stranding".  Absent the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   855
// MEMBAR, a thread in fast_unlock() can race a thread in the slow
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   856
// ::enter() path, resulting in the entering thread being stranding
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   857
// and a progress-liveness failure.   Stranding is extremely rare.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   858
// We use timers (timed park operations) & periodic polling to detect
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   859
// and recover from stranding.  Potentially stranded threads periodically
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   860
// wake up and poll the lock.  See the usage of the _Responsible variable.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   861
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   862
// The CAS() in enter provides for safety and exclusion, while the CAS or
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   863
// MEMBAR in exit provides for progress and avoids stranding.  1-0 locking
37251
9fc139ad74b5 8152358: code and comment cleanups found during the hunt for 8077392
dcubed
parents: 37092
diff changeset
   864
// eliminates the CAS/MEMBAR from the exit path, but it admits stranding.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   865
// We detect and recover from stranding with timers.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   866
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   867
// If a thread transiently strands it'll park until (a) another
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   868
// thread acquires the lock and then drops the lock, at which time the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   869
// exiting thread will notice and unpark the stranded thread, or, (b)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   870
// the timer expires.  If the lock is high traffic then the stranding latency
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   871
// will be low due to (a).  If the lock is low traffic then the odds of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   872
// stranding are lower, although the worst-case stranding latency
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   873
// is longer.  Critically, we don't want to put excessive load in the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   874
// platform's timer subsystem.  We want to minimize both the timer injection
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   875
// rate (timers created/sec) as well as the number of timers active at
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   876
// any one time.  (more precisely, we want to minimize timer-seconds, which is
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   877
// the integral of the # of active timers at any instant over time).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   878
// Both impinge on OS scalability.  Given that, at most one thread parked on
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   879
// a monitor will use a timer.
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   880
//
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   881
// There is also the risk of a futile wake-up. If we drop the lock
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   882
// another thread can reacquire the lock immediately, and we can
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   883
// then wake a thread unnecessarily. This is benign, and we've
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   884
// structured the code so the windows are short and the frequency
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
   885
// of such futile wakups is low.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   886
37092
0e56e3c9d545 8151593: Cleanup definition/usage of INLINE/NOINLINE macros and add xlC support
simonis
parents: 36384
diff changeset
   887
void ObjectMonitor::exit(bool not_suspended, TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   888
  Thread * const Self = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   889
  if (THREAD != _owner) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   890
    if (THREAD->is_lock_owned((address) _owner)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   891
      // Transmute _owner from a BasicLock pointer to a Thread address.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   892
      // We don't need to hold _mutex for this transition.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   893
      // Non-null to Non-null is safe as long as all readers can
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   894
      // tolerate either flavor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   895
      assert(_recursions == 0, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   896
      _owner = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   897
      _recursions = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   898
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   899
      // Apparent unbalanced locking ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   900
      // Naively we'd like to throw IllegalMonitorStateException.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   901
      // As a practical matter we can neither allocate nor throw an
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   902
      // exception as ::exit() can be called from leaf routines.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   903
      // see x86_32.ad Fast_Unlock() and the I1 and I2 properties.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   904
      // Upon deeper reflection, however, in a properly run JVM the only
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   905
      // way we should encounter this situation is in the presence of
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   906
      // unbalanced JNI locking. TODO: CheckJNICalls.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   907
      // See also: CR4414101
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   908
      TEVENT(Exit - Throw IMSX);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   909
      assert(false, "Non-balanced monitor enter/exit! Likely JNI locking");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   910
      return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   911
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   912
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   913
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   914
  if (_recursions != 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   915
    _recursions--;        // this is simple recursive enter
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   916
    TEVENT(Inflated exit - recursive);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   917
    return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   918
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   919
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   920
  // Invariant: after setting Responsible=null an thread must execute
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   921
  // a MEMBAR or other serializing instruction before fetching EntryList|cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   922
  if ((SyncFlags & 4) == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   923
    _Responsible = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   924
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   925
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   926
#if INCLUDE_TRACE
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   927
  // get the owner's thread id for the MonitorEnter event
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   928
  // if it is enabled and the thread isn't suspended
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   929
  if (not_suspended && Tracing::is_event_enabled(TraceJavaMonitorEnterEvent)) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
   930
    _previous_owner_tid = THREAD_TRACE_ID(Self);
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   931
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   932
#endif
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
   933
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   934
  for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   935
    assert(THREAD == _owner, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   936
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   937
    if (Knob_ExitPolicy == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   938
      // release semantics: prior loads and stores from within the critical section
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   939
      // must not float (reorder) past the following store that drops the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   940
      // On SPARC that requires MEMBAR #loadstore|#storestore.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   941
      // But of course in TSO #loadstore|#storestore is not required.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   942
      // I'd like to write one of the following:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   943
      // A.  OrderAccess::release() ; _owner = NULL
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   944
      // B.  OrderAccess::loadstore(); OrderAccess::storestore(); _owner = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   945
      // Unfortunately OrderAccess::release() and OrderAccess::loadstore() both
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   946
      // store into a _dummy variable.  That store is not needed, but can result
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   947
      // in massive wasteful coherency traffic on classic SMP systems.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   948
      // Instead, I use release_store(), which is implemented as just a simple
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   949
      // ST on x64, x86 and SPARC.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   950
      OrderAccess::release_store_ptr(&_owner, NULL);   // drop the lock
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
   951
      OrderAccess::storeload();                        // See if we need to wake a successor
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   952
      if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   953
        TEVENT(Inflated exit - simple egress);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   954
        return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   955
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   956
      TEVENT(Inflated exit - complex egress);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   957
      // Other threads are blocked trying to acquire the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   958
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   959
      // Normally the exiting thread is responsible for ensuring succession,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   960
      // but if other successors are ready or other entering threads are spinning
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   961
      // then this thread can simply store NULL into _owner and exit without
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   962
      // waking a successor.  The existence of spinners or ready successors
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   963
      // guarantees proper succession (liveness).  Responsibility passes to the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   964
      // ready or running successors.  The exiting thread delegates the duty.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   965
      // More precisely, if a successor already exists this thread is absolved
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   966
      // of the responsibility of waking (unparking) one.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   967
      //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   968
      // The _succ variable is critical to reducing futile wakeup frequency.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   969
      // _succ identifies the "heir presumptive" thread that has been made
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   970
      // ready (unparked) but that has not yet run.  We need only one such
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   971
      // successor thread to guarantee progress.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   972
      // See http://www.usenix.org/events/jvm01/full_papers/dice/dice.pdf
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   973
      // section 3.3 "Futile Wakeup Throttling" for details.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   974
      //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   975
      // Note that spinners in Enter() also set _succ non-null.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   976
      // In the current implementation spinners opportunistically set
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   977
      // _succ so that exiting threads might avoid waking a successor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   978
      // Another less appealing alternative would be for the exiting thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   979
      // to drop the lock and then spin briefly to see if a spinner managed
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   980
      // to acquire the lock.  If so, the exiting thread could exit
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   981
      // immediately without waking a successor, otherwise the exiting
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   982
      // thread would need to dequeue and wake a successor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   983
      // (Note that we'd need to make the post-drop spin short, but no
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   984
      // shorter than the worst-case round-trip cache-line migration time.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   985
      // The dropped lock needs to become visible to the spinner, and then
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   986
      // the acquisition of the lock by the spinner must become visible to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   987
      // the exiting thread).
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
   988
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   989
      // It appears that an heir-presumptive (successor) must be made ready.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   990
      // Only the current lock owner can manipulate the EntryList or
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   991
      // drain _cxq, so we need to reacquire the lock.  If we fail
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   992
      // to reacquire the lock the responsibility for ensuring succession
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   993
      // falls to the new owner.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   994
      //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   995
      if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   996
        return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   997
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   998
      TEVENT(Exit - Reacquired);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
   999
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1000
      if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1001
        OrderAccess::release_store_ptr(&_owner, NULL);   // drop the lock
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1002
        OrderAccess::storeload();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1003
        // Ratify the previously observed values.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1004
        if (_cxq == NULL || _succ != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1005
          TEVENT(Inflated exit - simple egress);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1006
          return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1007
        }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1008
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1009
        // inopportune interleaving -- the exiting thread (this thread)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1010
        // in the fast-exit path raced an entering thread in the slow-enter
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1011
        // path.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1012
        // We have two choices:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1013
        // A.  Try to reacquire the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1014
        //     If the CAS() fails return immediately, otherwise
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1015
        //     we either restart/rerun the exit operation, or simply
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1016
        //     fall-through into the code below which wakes a successor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1017
        // B.  If the elements forming the EntryList|cxq are TSM
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1018
        //     we could simply unpark() the lead thread and return
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1019
        //     without having set _succ.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1020
        if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1021
          TEVENT(Inflated exit - reacquired succeeded);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1022
          return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1023
        }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1024
        TEVENT(Inflated exit - reacquired failed);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1025
      } else {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1026
        TEVENT(Inflated exit - complex egress);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1027
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1028
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1029
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1030
    guarantee(_owner == THREAD, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1031
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1032
    ObjectWaiter * w = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1033
    int QMode = Knob_QMode;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1034
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1035
    if (QMode == 2 && _cxq != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1036
      // QMode == 2 : cxq has precedence over EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1037
      // Try to directly wake a successor from the cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1038
      // If successful, the successor will need to unlink itself from cxq.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1039
      w = _cxq;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1040
      assert(w != NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1041
      assert(w->TState == ObjectWaiter::TS_CXQ, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1042
      ExitEpilog(Self, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1043
      return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1044
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1045
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1046
    if (QMode == 3 && _cxq != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1047
      // Aggressively drain cxq into EntryList at the first opportunity.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1048
      // This policy ensure that recently-run threads live at the head of EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1049
      // Drain _cxq into EntryList - bulk transfer.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1050
      // First, detach _cxq.
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1051
      // The following loop is tantamount to: w = swap(&cxq, NULL)
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1052
      w = _cxq;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1053
      for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1054
        assert(w != NULL, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1055
        ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1056
        if (u == w) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1057
        w = u;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1058
      }
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1059
      assert(w != NULL, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1060
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1061
      ObjectWaiter * q = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1062
      ObjectWaiter * p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1063
      for (p = w; p != NULL; p = p->_next) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1064
        guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1065
        p->TState = ObjectWaiter::TS_ENTER;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1066
        p->_prev = q;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1067
        q = p;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1068
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
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
      // Append the RATs to the EntryList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1071
      // TODO: organize EntryList as a CDLL so we can locate the tail in constant-time.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1072
      ObjectWaiter * Tail;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1073
      for (Tail = _EntryList; Tail != NULL && Tail->_next != NULL;
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1074
           Tail = Tail->_next)
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1075
        /* empty */;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1076
      if (Tail == NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1077
        _EntryList = w;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1078
      } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1079
        Tail->_next = w;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1080
        w->_prev = Tail;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1081
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1082
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1083
      // Fall thru into code that tries to wake a successor from EntryList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1084
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1085
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1086
    if (QMode == 4 && _cxq != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1087
      // Aggressively drain cxq into EntryList at the first opportunity.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1088
      // This policy ensure that recently-run threads live at the head of EntryList.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1089
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1090
      // Drain _cxq into EntryList - bulk transfer.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1091
      // First, detach _cxq.
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1092
      // The following loop is tantamount to: w = swap(&cxq, NULL)
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1093
      w = _cxq;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1094
      for (;;) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1095
        assert(w != NULL, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1096
        ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1097
        if (u == w) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1098
        w = u;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1099
      }
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1100
      assert(w != NULL, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1101
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1102
      ObjectWaiter * q = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1103
      ObjectWaiter * p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1104
      for (p = w; p != NULL; p = p->_next) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1105
        guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1106
        p->TState = ObjectWaiter::TS_ENTER;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1107
        p->_prev = q;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1108
        q = p;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1109
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1110
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1111
      // Prepend the RATs to the EntryList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1112
      if (_EntryList != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1113
        q->_next = _EntryList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1114
        _EntryList->_prev = q;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1115
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1116
      _EntryList = w;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1117
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1118
      // Fall thru into code that tries to wake a successor from EntryList
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1119
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1120
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1121
    w = _EntryList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1122
    if (w != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1123
      // I'd like to write: guarantee (w->_thread != Self).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1124
      // But in practice an exiting thread may find itself on the EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1125
      // Let's say thread T1 calls O.wait().  Wait() enqueues T1 on O's waitset and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1126
      // then calls exit().  Exit release the lock by setting O._owner to NULL.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1127
      // Let's say T1 then stalls.  T2 acquires O and calls O.notify().  The
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1128
      // notify() operation moves T1 from O's waitset to O's EntryList. T2 then
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1129
      // release the lock "O".  T2 resumes immediately after the ST of null into
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1130
      // _owner, above.  T2 notices that the EntryList is populated, so it
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1131
      // reacquires the lock and then finds itself on the EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1132
      // Given all that, we have to tolerate the circumstance where "w" is
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1133
      // associated with Self.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1134
      assert(w->TState == ObjectWaiter::TS_ENTER, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1135
      ExitEpilog(Self, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1136
      return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1137
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1138
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1139
    // If we find that both _cxq and EntryList are null then just
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1140
    // re-run the exit protocol from the top.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1141
    w = _cxq;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1142
    if (w == NULL) continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1143
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1144
    // Drain _cxq into EntryList - bulk transfer.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1145
    // First, detach _cxq.
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1146
    // The following loop is tantamount to: w = swap(&cxq, NULL)
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1147
    for (;;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1148
      assert(w != NULL, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1149
      ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr(NULL, &_cxq, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1150
      if (u == w) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1151
      w = u;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1152
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1153
    TEVENT(Inflated exit - drain cxq into EntryList);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1154
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1155
    assert(w != NULL, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1156
    assert(_EntryList == NULL, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1157
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1158
    // Convert the LIFO SLL anchored by _cxq into a DLL.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1159
    // The list reorganization step operates in O(LENGTH(w)) time.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1160
    // It's critical that this step operate quickly as
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1161
    // "Self" still holds the outer-lock, restricting parallelism
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1162
    // and effectively lengthening the critical section.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1163
    // Invariant: s chases t chases u.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1164
    // TODO-FIXME: consider changing EntryList from a DLL to a CDLL so
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1165
    // we have faster access to the tail.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1166
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1167
    if (QMode == 1) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1168
      // QMode == 1 : drain cxq to EntryList, reversing order
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1169
      // We also reverse the order of the list.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1170
      ObjectWaiter * s = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1171
      ObjectWaiter * t = w;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1172
      ObjectWaiter * u = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1173
      while (t != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1174
        guarantee(t->TState == ObjectWaiter::TS_CXQ, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1175
        t->TState = ObjectWaiter::TS_ENTER;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1176
        u = t->_next;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1177
        t->_prev = u;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1178
        t->_next = s;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1179
        s = t;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1180
        t = u;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1181
      }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1182
      _EntryList  = s;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1183
      assert(s != NULL, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1184
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1185
      // QMode == 0 or QMode == 2
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1186
      _EntryList = w;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1187
      ObjectWaiter * q = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1188
      ObjectWaiter * p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1189
      for (p = w; p != NULL; p = p->_next) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1190
        guarantee(p->TState == ObjectWaiter::TS_CXQ, "Invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1191
        p->TState = ObjectWaiter::TS_ENTER;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1192
        p->_prev = q;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1193
        q = p;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1194
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1195
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1196
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1197
    // In 1-0 mode we need: ST EntryList; MEMBAR #storestore; ST _owner = NULL
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1198
    // The MEMBAR is satisfied by the release_store() operation in ExitEpilog().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1199
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1200
    // See if we can abdicate to a spinner instead of waking a thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1201
    // A primary goal of the implementation is to reduce the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1202
    // context-switch rate.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1203
    if (_succ != NULL) continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1204
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1205
    w = _EntryList;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1206
    if (w != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1207
      guarantee(w->TState == ObjectWaiter::TS_ENTER, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1208
      ExitEpilog(Self, w);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1209
      return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1210
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1211
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1212
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1213
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1214
// ExitSuspendEquivalent:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1215
// A faster alternate to handle_special_suspend_equivalent_condition()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1216
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1217
// handle_special_suspend_equivalent_condition() unconditionally
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1218
// acquires the SR_lock.  On some platforms uncontended MutexLocker()
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1219
// operations have high latency.  Note that in ::enter() we call HSSEC
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1220
// while holding the monitor, so we effectively lengthen the critical sections.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1221
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1222
// There are a number of possible solutions:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1223
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1224
// A.  To ameliorate the problem we might also defer state transitions
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1225
//     to as late as possible -- just prior to parking.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1226
//     Given that, we'd call HSSEC after having returned from park(),
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1227
//     but before attempting to acquire the monitor.  This is only a
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1228
//     partial solution.  It avoids calling HSSEC while holding the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1229
//     monitor (good), but it still increases successor reacquisition latency --
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1230
//     the interval between unparking a successor and the time the successor
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1231
//     resumes and retries the lock.  See ReenterI(), which defers state transitions.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1232
//     If we use this technique we can also avoid EnterI()-exit() loop
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1233
//     in ::enter() where we iteratively drop the lock and then attempt
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1234
//     to reacquire it after suspending.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1235
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1236
// B.  In the future we might fold all the suspend bits into a
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1237
//     composite per-thread suspend flag and then update it with CAS().
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1238
//     Alternately, a Dekker-like mechanism with multiple variables
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1239
//     would suffice:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1240
//       ST Self->_suspend_equivalent = false
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1241
//       MEMBAR
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1242
//       LD Self_>_suspend_flags
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1243
//
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1244
// UPDATE 2007-10-6: since I've replaced the native Mutex/Monitor subsystem
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1245
// with a more efficient implementation, the need to use "FastHSSEC" has
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1246
// decreased. - Dave
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1247
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1248
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1249
bool ObjectMonitor::ExitSuspendEquivalent(JavaThread * jSelf) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1250
  const int Mode = Knob_FastHSSEC;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1251
  if (Mode && !jSelf->is_external_suspend()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1252
    assert(jSelf->is_suspend_equivalent(), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1253
    jSelf->clear_suspend_equivalent();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1254
    if (2 == Mode) OrderAccess::storeload();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1255
    if (!jSelf->is_external_suspend()) return false;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1256
    // We raced a suspension -- fall thru into the slow path
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1257
    TEVENT(ExitSuspendEquivalent - raced);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1258
    jSelf->set_suspend_equivalent();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1259
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1260
  return jSelf->handle_special_suspend_equivalent_condition();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1261
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1262
dc9b63952682 6988353: refactor contended sync subsystem
acorn
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 ObjectMonitor::ExitEpilog(Thread * Self, ObjectWaiter * Wakee) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1265
  assert(_owner == Self, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1266
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1267
  // Exit protocol:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1268
  // 1. ST _succ = wakee
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1269
  // 2. membar #loadstore|#storestore;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1270
  // 2. ST _owner = NULL
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1271
  // 3. unpark(wakee)
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1272
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1273
  _succ = Knob_SuccEnabled ? Wakee->_thread : NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1274
  ParkEvent * Trigger = Wakee->_event;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1275
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1276
  // Hygiene -- once we've set _owner = NULL we can't safely dereference Wakee again.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1277
  // The thread associated with Wakee may have grabbed the lock and "Wakee" may be
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1278
  // out-of-scope (non-extant).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1279
  Wakee  = NULL;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1280
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1281
  // Drop the lock
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1282
  OrderAccess::release_store_ptr(&_owner, NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1283
  OrderAccess::fence();                               // ST _owner vs LD in unpark()
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1284
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1285
  if (SafepointSynchronize::do_call_back()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1286
    TEVENT(unpark before SAFEPOINT);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1287
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1288
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1289
  DTRACE_MONITOR_PROBE(contended__exit, this, object(), Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1290
  Trigger->unpark();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1291
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1292
  // Maintain stats and report events to JVMTI
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1293
  OM_PERFDATA_OP(Parks, inc());
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1294
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1295
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1296
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1297
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1298
// Class Loader deadlock handling.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1299
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1300
// complete_exit exits a lock returning recursion count
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1301
// complete_exit/reenter operate as a wait without waiting
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1302
// complete_exit requires an inflated monitor
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1303
// The _owner field is not always the Thread addr even with an
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1304
// inflated monitor, e.g. the monitor can be inflated by a non-owning
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1305
// thread due to contention.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1306
intptr_t ObjectMonitor::complete_exit(TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1307
  Thread * const Self = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1308
  assert(Self->is_Java_thread(), "Must be Java thread!");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1309
  JavaThread *jt = (JavaThread *)THREAD;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1310
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1311
  DeferredInitialize();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1312
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1313
  if (THREAD != _owner) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1314
    if (THREAD->is_lock_owned ((address)_owner)) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1315
      assert(_recursions == 0, "internal state error");
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1316
      _owner = THREAD;   // Convert from basiclock addr to Thread addr
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1317
      _recursions = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1318
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1319
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1320
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1321
  guarantee(Self == _owner, "complete_exit not owner");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1322
  intptr_t save = _recursions; // record the old recursion count
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1323
  _recursions = 0;        // set the recursion level to be 0
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1324
  exit(true, Self);           // exit the monitor
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1325
  guarantee(_owner != Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1326
  return save;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1327
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1328
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1329
// reenter() enters a lock and sets recursion count
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1330
// complete_exit/reenter operate as a wait without waiting
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1331
void ObjectMonitor::reenter(intptr_t recursions, TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1332
  Thread * const Self = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1333
  assert(Self->is_Java_thread(), "Must be Java thread!");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1334
  JavaThread *jt = (JavaThread *)THREAD;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1335
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1336
  guarantee(_owner != Self, "reenter already owner");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1337
  enter(THREAD);       // enter the monitor
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1338
  guarantee(_recursions == 0, "reenter recursion");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1339
  _recursions = recursions;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1340
  return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1341
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1342
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1343
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1344
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1345
// A macro is used below because there may already be a pending
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1346
// exception which should not abort the execution of the routines
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1347
// which use this (which is why we don't put this into check_slow and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1348
// call it with a CHECK argument).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1349
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1350
#define CHECK_OWNER()                                                       \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1351
  do {                                                                      \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1352
    if (THREAD != _owner) {                                                 \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1353
      if (THREAD->is_lock_owned((address) _owner)) {                        \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1354
        _owner = THREAD;  /* Convert from basiclock addr to Thread addr */  \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1355
        _recursions = 0;                                                    \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1356
      } else {                                                              \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1357
        TEVENT(Throw IMSX);                                                 \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1358
        THROW(vmSymbols::java_lang_IllegalMonitorStateException());         \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1359
      }                                                                     \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1360
    }                                                                       \
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1361
  } while (false)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1362
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1363
// check_slow() is a misnomer.  It's called to simply to throw an IMSX exception.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1364
// TODO-FIXME: remove check_slow() -- it's likely dead.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1365
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1366
void ObjectMonitor::check_slow(TRAPS) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1367
  TEVENT(check_slow - throw IMSX);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1368
  assert(THREAD != _owner && !THREAD->is_lock_owned((address) _owner), "must not be owner");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1369
  THROW_MSG(vmSymbols::java_lang_IllegalMonitorStateException(), "current thread not owner");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1370
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1371
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1372
static int Adjust(volatile int * adr, int dx) {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1373
  int v;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1374
  for (v = *adr; Atomic::cmpxchg(v + dx, adr, v) != v; v = *adr) /* empty */;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1375
  return v;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1376
}
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1377
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1378
// helper method for posting a monitor wait event
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1379
void ObjectMonitor::post_monitor_wait_event(EventJavaMonitorWait* event,
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1380
                                            jlong notifier_tid,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1381
                                            jlong timeout,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1382
                                            bool timedout) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1383
  assert(event != NULL, "invariant");
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 40655
diff changeset
  1384
  event->set_monitorClass(((oop)this->object())->klass());
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1385
  event->set_timeout(timeout);
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1386
  event->set_address((TYPE_ADDRESS)this->object_addr());
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1387
  event->set_notifier(notifier_tid);
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1388
  event->set_timedOut(timedout);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1389
  event->commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1390
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1391
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1392
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1393
// Wait/Notify/NotifyAll
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1394
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1395
// Note: a subset of changes to ObjectMonitor::wait()
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  1396
// will need to be replicated in complete_exit
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1397
void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1398
  Thread * const Self = THREAD;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1399
  assert(Self->is_Java_thread(), "Must be Java thread!");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1400
  JavaThread *jt = (JavaThread *)THREAD;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1401
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1402
  DeferredInitialize();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1403
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1404
  // Throw IMSX or IEX.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1405
  CHECK_OWNER();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1406
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1407
  EventJavaMonitorWait event;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1408
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1409
  // check for a pending interrupt
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1410
  if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1411
    // post monitor waited event.  Note that this is past-tense, we are done waiting.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1412
    if (JvmtiExport::should_post_monitor_waited()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1413
      // Note: 'false' parameter is passed here because the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1414
      // wait was not timed out due to thread interrupt.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1415
      JvmtiExport::post_monitor_waited(jt, this, false);
22753
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
  1416
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1417
      // In this short circuit of the monitor wait protocol, the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1418
      // current thread never drops ownership of the monitor and
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1419
      // never gets added to the wait queue so the current thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1420
      // cannot be made the successor. This means that the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1421
      // JVMTI_EVENT_MONITOR_WAITED event handler cannot accidentally
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1422
      // consume an unpark() meant for the ParkEvent associated with
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1423
      // this ObjectMonitor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1424
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1425
    if (event.should_commit()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1426
      post_monitor_wait_event(&event, 0, millis, false);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1427
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1428
    TEVENT(Wait - Throw IEX);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1429
    THROW(vmSymbols::java_lang_InterruptedException());
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1430
    return;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1431
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1432
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1433
  TEVENT(Wait);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1434
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1435
  assert(Self->_Stalled == 0, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1436
  Self->_Stalled = intptr_t(this);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1437
  jt->set_current_waiting_monitor(this);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1438
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1439
  // create a node to be put into the queue
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1440
  // Critically, after we reset() the event but prior to park(), we must check
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1441
  // for a pending interrupt.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1442
  ObjectWaiter node(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1443
  node.TState = ObjectWaiter::TS_WAIT;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1444
  Self->_ParkEvent->reset();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1445
  OrderAccess::fence();          // ST into Event; membar ; LD interrupted-flag
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
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
  // Enter the waiting queue, which is a circular doubly linked list in this case
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1448
  // but it could be a priority queue or any data structure.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1449
  // _WaitSetLock protects the wait queue.  Normally the wait queue is accessed only
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1450
  // by the the owner of the monitor *except* in the case where park()
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1451
  // returns because of a timeout of interrupt.  Contention is exceptionally rare
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1452
  // so we use a simple spin-lock instead of a heavier-weight blocking lock.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1453
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1454
  Thread::SpinAcquire(&_WaitSetLock, "WaitSet - add");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1455
  AddWaiter(&node);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1456
  Thread::SpinRelease(&_WaitSetLock);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1457
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1458
  if ((SyncFlags & 4) == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1459
    _Responsible = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1460
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1461
  intptr_t save = _recursions; // record the old recursion count
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1462
  _waiters++;                  // increment the number of waiters
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1463
  _recursions = 0;             // set the recursion level to be 1
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1464
  exit(true, Self);                    // exit the monitor
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1465
  guarantee(_owner != Self, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1466
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1467
  // The thread is on the WaitSet list - now park() it.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1468
  // On MP systems it's conceivable that a brief spin before we park
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1469
  // could be profitable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1470
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1471
  // TODO-FIXME: change the following logic to a loop of the form
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1472
  //   while (!timeout && !interrupted && _notified == 0) park()
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1473
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1474
  int ret = OS_OK;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1475
  int WasNotified = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1476
  { // State transition wrappers
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1477
    OSThread* osthread = Self->osthread();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1478
    OSThreadWaitState osts(osthread, true);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1479
    {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1480
      ThreadBlockInVM tbivm(jt);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1481
      // Thread is in thread_blocked state and oop access is unsafe.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1482
      jt->set_suspend_equivalent();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1483
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1484
      if (interruptible && (Thread::is_interrupted(THREAD, false) || HAS_PENDING_EXCEPTION)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1485
        // Intentionally empty
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1486
      } else if (node._notified == 0) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1487
        if (millis <= 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1488
          Self->_ParkEvent->park();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1489
        } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1490
          ret = Self->_ParkEvent->park(millis);
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
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1493
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1494
      // were we externally suspended while we were waiting?
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1495
      if (ExitSuspendEquivalent (jt)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1496
        // TODO-FIXME: add -- if succ == Self then succ = null.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1497
        jt->java_suspend_self();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1498
      }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1499
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1500
    } // Exit thread safepoint: transition _thread_blocked -> _thread_in_vm
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1501
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1502
    // Node may be on the WaitSet, the EntryList (or cxq), or in transition
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1503
    // from the WaitSet to the EntryList.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1504
    // See if we need to remove Node from the WaitSet.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1505
    // We use double-checked locking to avoid grabbing _WaitSetLock
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1506
    // if the thread is not on the wait queue.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1507
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1508
    // Note that we don't need a fence before the fetch of TState.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1509
    // In the worst case we'll fetch a old-stale value of TS_WAIT previously
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1510
    // written by the is thread. (perhaps the fetch might even be satisfied
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1511
    // by a look-aside into the processor's own store buffer, although given
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1512
    // the length of the code path between the prior ST and this load that's
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1513
    // highly unlikely).  If the following LD fetches a stale TS_WAIT value
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1514
    // then we'll acquire the lock and then re-fetch a fresh TState value.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1515
    // That is, we fail toward safety.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1516
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1517
    if (node.TState == ObjectWaiter::TS_WAIT) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1518
      Thread::SpinAcquire(&_WaitSetLock, "WaitSet - unlink");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1519
      if (node.TState == ObjectWaiter::TS_WAIT) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1520
        DequeueSpecificWaiter(&node);       // unlink from WaitSet
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1521
        assert(node._notified == 0, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1522
        node.TState = ObjectWaiter::TS_RUN;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1523
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1524
      Thread::SpinRelease(&_WaitSetLock);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1525
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1526
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1527
    // The thread is now either on off-list (TS_RUN),
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1528
    // on the EntryList (TS_ENTER), or on the cxq (TS_CXQ).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1529
    // The Node's TState variable is stable from the perspective of this thread.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1530
    // No other threads will asynchronously modify TState.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1531
    guarantee(node.TState != ObjectWaiter::TS_WAIT, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1532
    OrderAccess::loadload();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1533
    if (_succ == Self) _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1534
    WasNotified = node._notified;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1535
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1536
    // Reentry phase -- reacquire the monitor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1537
    // re-enter contended monitor after object.wait().
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1538
    // retain OBJECT_WAIT state until re-enter successfully completes
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1539
    // Thread state is thread_in_vm and oop access is again safe,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1540
    // although the raw address of the object may have changed.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1541
    // (Don't cache naked oops over safepoints, of course).
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1542
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1543
    // post monitor waited event. Note that this is past-tense, we are done waiting.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1544
    if (JvmtiExport::should_post_monitor_waited()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1545
      JvmtiExport::post_monitor_waited(jt, this, ret == OS_TIMEOUT);
22753
749328896281 8028073: race condition in ObjectMonitor implementation causing deadlocks
dcubed
parents: 22551
diff changeset
  1546
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1547
      if (node._notified != 0 && _succ == Self) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1548
        // In this part of the monitor wait-notify-reenter protocol it
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1549
        // is possible (and normal) for another thread to do a fastpath
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1550
        // monitor enter-exit while this thread is still trying to get
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1551
        // to the reenter portion of the protocol.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1552
        //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1553
        // The ObjectMonitor was notified and the current thread is
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1554
        // the successor which also means that an unpark() has already
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1555
        // been done. The JVMTI_EVENT_MONITOR_WAITED event handler can
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1556
        // consume the unpark() that was done when the successor was
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1557
        // set because the same ParkEvent is shared between Java
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1558
        // monitors and JVM/TI RawMonitors (for now).
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1559
        //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1560
        // We redo the unpark() to ensure forward progress, i.e., we
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1561
        // don't want all pending threads hanging (parked) with none
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1562
        // entering the unlocked monitor.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1563
        node._event->unpark();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1564
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1565
    }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1566
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1567
    if (event.should_commit()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1568
      post_monitor_wait_event(&event, node._notifier_tid, millis, ret == OS_TIMEOUT);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1569
    }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17087
diff changeset
  1570
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1571
    OrderAccess::fence();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1572
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1573
    assert(Self->_Stalled != 0, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1574
    Self->_Stalled = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1575
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1576
    assert(_owner != Self, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1577
    ObjectWaiter::TStates v = node.TState;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1578
    if (v == ObjectWaiter::TS_RUN) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1579
      enter(Self);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1580
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1581
      guarantee(v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1582
      ReenterI(Self, &node);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1583
      node.wait_reenter_end(this);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1584
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1585
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1586
    // Self has reacquired the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1587
    // Lifecycle - the node representing Self must not appear on any queues.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1588
    // Node is about to go out-of-scope, but even if it were immortal we wouldn't
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1589
    // want residual elements associated with this thread left on any lists.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1590
    guarantee(node.TState == ObjectWaiter::TS_RUN, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1591
    assert(_owner == Self, "invariant");
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1592
    assert(_succ != Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1593
  } // OSThreadWaitState()
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1594
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1595
  jt->set_current_waiting_monitor(NULL);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1596
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1597
  guarantee(_recursions == 0, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1598
  _recursions = save;     // restore the old recursion count
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1599
  _waiters--;             // decrement the number of waiters
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1600
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1601
  // Verify a few postconditions
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1602
  assert(_owner == Self, "invariant");
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  1603
  assert(_succ != Self, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1604
  assert(((oop)(object()))->mark() == markOopDesc::encode(this), "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1605
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1606
  if (SyncFlags & 32) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1607
    OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1608
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1609
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1610
  // check if the notification happened
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1611
  if (!WasNotified) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1612
    // no, it could be timeout or Thread.interrupt() or both
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1613
    // check for interrupt event, otherwise it is timeout
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1614
    if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1615
      TEVENT(Wait - throw IEX from epilog);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1616
      THROW(vmSymbols::java_lang_InterruptedException());
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1617
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1618
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1619
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1620
  // NOTE: Spurious wake up will be consider as timeout.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1621
  // Monitor notify has precedence over thread interrupt.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1622
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1623
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1624
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1625
// Consider:
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1626
// If the lock is cool (cxq == null && succ == null) and we're on an MP system
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1627
// then instead of transferring a thread from the WaitSet to the EntryList
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1628
// we might just dequeue a thread from the WaitSet and directly unpark() it.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1629
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1630
void ObjectMonitor::INotify(Thread * Self) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1631
  const int policy = Knob_MoveNotifyee;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1632
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1633
  Thread::SpinAcquire(&_WaitSetLock, "WaitSet - notify");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1634
  ObjectWaiter * iterator = DequeueWaiter();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1635
  if (iterator != NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1636
    TEVENT(Notify1 - Transfer);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1637
    guarantee(iterator->TState == ObjectWaiter::TS_WAIT, "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1638
    guarantee(iterator->_notified == 0, "invariant");
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1639
    // Disposition - what might we do with iterator ?
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1640
    // a.  add it directly to the EntryList - either tail (policy == 1)
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1641
    //     or head (policy == 0).
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1642
    // b.  push it onto the front of the _cxq (policy == 2).
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1643
    // For now we use (b).
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1644
    if (policy != 4) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1645
      iterator->TState = ObjectWaiter::TS_ENTER;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1646
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1647
    iterator->_notified = 1;
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35529
diff changeset
  1648
    iterator->_notifier_tid = THREAD_TRACE_ID(Self);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1649
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1650
    ObjectWaiter * list = _EntryList;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1651
    if (list != NULL) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1652
      assert(list->_prev == NULL, "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1653
      assert(list->TState == ObjectWaiter::TS_ENTER, "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1654
      assert(list != iterator, "invariant");
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1655
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1656
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1657
    if (policy == 0) {       // prepend to EntryList
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1658
      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
  1659
        iterator->_next = iterator->_prev = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1660
        _EntryList = iterator;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1661
      } else {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1662
        list->_prev = iterator;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1663
        iterator->_next = list;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1664
        iterator->_prev = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1665
        _EntryList = iterator;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1666
      }
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1667
    } else if (policy == 1) {      // append to EntryList
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1668
      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
  1669
        iterator->_next = iterator->_prev = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1670
        _EntryList = iterator;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1671
      } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1672
        // CONSIDER:  finding the tail currently requires a linear-time walk of
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1673
        // the EntryList.  We can make tail access constant-time by converting to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1674
        // a CDLL instead of using our current DLL.
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1675
        ObjectWaiter * tail;
46630
75aa3e39d02c 8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents: 46342
diff changeset
  1676
        for (tail = list; tail->_next != NULL; tail = tail->_next) {}
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1677
        assert(tail != NULL && tail->_next == NULL, "invariant");
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1678
        tail->_next = iterator;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1679
        iterator->_prev = tail;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1680
        iterator->_next = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1681
      }
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1682
    } else if (policy == 2) {      // prepend to cxq
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1683
      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
  1684
        iterator->_next = iterator->_prev = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1685
        _EntryList = iterator;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1686
      } else {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1687
        iterator->TState = ObjectWaiter::TS_CXQ;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1688
        for (;;) {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1689
          ObjectWaiter * front = _cxq;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1690
          iterator->_next = front;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1691
          if (Atomic::cmpxchg_ptr(iterator, &_cxq, front) == front) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1692
            break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1693
          }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1694
        }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1695
      }
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1696
    } else if (policy == 3) {      // append to cxq
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1697
      iterator->TState = ObjectWaiter::TS_CXQ;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1698
      for (;;) {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1699
        ObjectWaiter * tail = _cxq;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1700
        if (tail == NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1701
          iterator->_next = NULL;
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1702
          if (Atomic::cmpxchg_ptr(iterator, &_cxq, NULL) == NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1703
            break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1704
          }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1705
        } else {
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1706
          while (tail->_next != NULL) tail = tail->_next;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1707
          tail->_next = iterator;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1708
          iterator->_prev = tail;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1709
          iterator->_next = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1710
          break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1711
        }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1712
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1713
    } else {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1714
      ParkEvent * ev = iterator->_event;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1715
      iterator->TState = ObjectWaiter::TS_RUN;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1716
      OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1717
      ev->unpark();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1718
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1719
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1720
    // _WaitSetLock protects the wait queue, not the EntryList.  We could
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1721
    // move the add-to-EntryList operation, above, outside the critical section
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1722
    // protected by _WaitSetLock.  In practice that's not useful.  With the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1723
    // exception of  wait() timeouts and interrupts the monitor owner
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1724
    // is the only thread that grabs _WaitSetLock.  There's almost no contention
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1725
    // on _WaitSetLock so it's not profitable to reduce the length of the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1726
    // critical section.
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1727
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1728
    if (policy < 4) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1729
      iterator->wait_reenter_begin(this);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1730
    }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1731
  }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1732
  Thread::SpinRelease(&_WaitSetLock);
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1733
}
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1734
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1735
// Consider: a not-uncommon synchronization bug is to use notify() when
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1736
// notifyAll() is more appropriate, potentially resulting in stranded
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1737
// threads; this is one example of a lost wakeup. A useful diagnostic
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1738
// option is to force all notify() operations to behave as notifyAll().
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1739
//
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1740
// Note: We can also detect many such problems with a "minimum wait".
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1741
// When the "minimum wait" is set to a small non-zero timeout value
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1742
// and the program does not hang whereas it did absent "minimum wait",
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1743
// that suggests a lost wakeup bug. The '-XX:SyncFlags=1' option uses
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1744
// a "minimum wait" for all park() operations; see the recheckInterval
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1745
// variable and MAX_RECHECK_INTERVAL.
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1746
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1747
void ObjectMonitor::notify(TRAPS) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1748
  CHECK_OWNER();
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1749
  if (_WaitSet == NULL) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1750
    TEVENT(Empty-Notify);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1751
    return;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1752
  }
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1753
  DTRACE_MONITOR_PROBE(notify, this, object(), THREAD);
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1754
  INotify(THREAD);
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1755
  OM_PERFDATA_OP(Notifications, inc(1));
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1756
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1757
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1758
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1759
// The current implementation of notifyAll() transfers the waiters one-at-a-time
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1760
// from the waitset to the EntryList. This could be done more efficiently with a
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1761
// single bulk transfer but in practice it's not time-critical. Beware too,
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1762
// that in prepend-mode we invert the order of the waiters. Let's say that the
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1763
// waitset is "ABCD" and the EntryList is "XYZ". After a notifyAll() in prepend
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1764
// mode the waitset will be empty and the EntryList will be "DCBAXYZ".
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1765
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1766
void ObjectMonitor::notifyAll(TRAPS) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1767
  CHECK_OWNER();
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1768
  if (_WaitSet == NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1769
    TEVENT(Empty-NotifyAll);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1770
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1771
  }
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1772
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1773
  DTRACE_MONITOR_PROBE(notifyAll, this, object(), THREAD);
31856
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1774
  int tally = 0;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1775
  while (_WaitSet != NULL) {
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1776
    tally++;
614d6786ba55 8075171: Contended Locking fast notify bucket
dcubed
parents: 31782
diff changeset
  1777
    INotify(THREAD);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1778
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1779
32614
b7b2407bc7e5 8049304: race between VM_Exit and _sync_FutileWakeups->inc()
dcubed
parents: 31856
diff changeset
  1780
  OM_PERFDATA_OP(Notifications, inc(tally));
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1781
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1782
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1783
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1784
// Adaptive Spinning Support
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1785
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1786
// Adaptive spin-then-block - rational spinning
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1787
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1788
// Note that we spin "globally" on _owner with a classic SMP-polite TATAS
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1789
// algorithm.  On high order SMP systems it would be better to start with
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1790
// a brief global spin and then revert to spinning locally.  In the spirit of MCS/CLH,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1791
// a contending thread could enqueue itself on the cxq and then spin locally
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1792
// on a thread-specific variable such as its ParkEvent._Event flag.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1793
// That's left as an exercise for the reader.  Note that global spinning is
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1794
// not problematic on Niagara, as the L2 cache serves the interconnect and
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  1795
// has both low latency and massive bandwidth.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1796
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1797
// Broadly, we can fix the spin frequency -- that is, the % of contended lock
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1798
// acquisition attempts where we opt to spin --  at 100% and vary the spin count
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1799
// (duration) or we can fix the count at approximately the duration of
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1800
// a context switch and vary the frequency.   Of course we could also
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1801
// vary both satisfying K == Frequency * Duration, where K is adaptive by monitor.
32622
7ed47d0b888a 8135002: Fix or remove broken links in objectMonitor.cpp comments
dbuck
parents: 32614
diff changeset
  1802
// For a description of 'Adaptive spin-then-block mutual exclusion in
7ed47d0b888a 8135002: Fix or remove broken links in objectMonitor.cpp comments
dbuck
parents: 32614
diff changeset
  1803
// multi-threaded processing,' see U.S. Pat. No. 8046758.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1804
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1805
// This implementation varies the duration "D", where D varies with
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1806
// the success rate of recent spin attempts. (D is capped at approximately
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1807
// length of a round-trip context switch).  The success rate for recent
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1808
// spin attempts is a good predictor of the success rate of future spin
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1809
// attempts.  The mechanism adapts automatically to varying critical
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1810
// section length (lock modality), system load and degree of parallelism.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1811
// D is maintained per-monitor in _SpinDuration and is initialized
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1812
// optimistically.  Spin frequency is fixed at 100%.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1813
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1814
// Note that _SpinDuration is volatile, but we update it without locks
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1815
// or atomics.  The code is designed so that _SpinDuration stays within
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1816
// a reasonable range even in the presence of races.  The arithmetic
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1817
// operations on _SpinDuration are closed over the domain of legal values,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1818
// so at worst a race will install and older but still legal value.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1819
// At the very worst this introduces some apparent non-determinism.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1820
// We might spin when we shouldn't or vice-versa, but since the spin
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1821
// count are relatively short, even in the worst case, the effect is harmless.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1822
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1823
// Care must be taken that a low "D" value does not become an
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1824
// an absorbing state.  Transient spinning failures -- when spinning
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1825
// is overall profitable -- should not cause the system to converge
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1826
// on low "D" values.  We want spinning to be stable and predictable
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1827
// and fairly responsive to change and at the same time we don't want
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1828
// it to oscillate, become metastable, be "too" non-deterministic,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1829
// or converge on or enter undesirable stable absorbing states.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1830
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1831
// We implement a feedback-based control system -- using past behavior
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1832
// to predict future behavior.  We face two issues: (a) if the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1833
// input signal is random then the spin predictor won't provide optimal
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1834
// results, and (b) if the signal frequency is too high then the control
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1835
// system, which has some natural response lag, will "chase" the signal.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1836
// (b) can arise from multimodal lock hold times.  Transient preemption
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1837
// can also result in apparent bimodal lock hold times.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1838
// Although sub-optimal, neither condition is particularly harmful, as
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1839
// in the worst-case we'll spin when we shouldn't or vice-versa.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1840
// The maximum spin duration is rather short so the failure modes aren't bad.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1841
// To be conservative, I've tuned the gain in system to bias toward
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1842
// _not spinning.  Relatedly, the system can sometimes enter a mode where it
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1843
// "rings" or oscillates between spinning and not spinning.  This happens
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1844
// when spinning is just on the cusp of profitability, however, so the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1845
// situation is not dire.  The state is benign -- there's no need to add
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1846
// hysteresis control to damp the transition rate between spinning and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1847
// not spinning.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1848
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1849
// Spinning: Fixed frequency (100%), vary duration
39702
ea7e9375bb93 8068592: Remove unused code in objectMonitor.hpp
dcubed
parents: 37251
diff changeset
  1850
int ObjectMonitor::TrySpin(Thread * Self) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1851
  // Dumb, brutal spin.  Good for comparative measurements against adaptive spinning.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1852
  int ctr = Knob_FixedSpin;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1853
  if (ctr != 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1854
    while (--ctr >= 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1855
      if (TryLock(Self) > 0) return 1;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1856
      SpinPause();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1857
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1858
    return 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1859
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1860
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1861
  for (ctr = Knob_PreSpin + 1; --ctr >= 0;) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1862
    if (TryLock(Self) > 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1863
      // Increase _SpinDuration ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1864
      // Note that we don't clamp SpinDuration precisely at SpinLimit.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1865
      // Raising _SpurDuration to the poverty line is key.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1866
      int x = _SpinDuration;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1867
      if (x < Knob_SpinLimit) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1868
        if (x < Knob_Poverty) x = Knob_Poverty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1869
        _SpinDuration = x + Knob_BonusB;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1870
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1871
      return 1;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1872
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1873
    SpinPause();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1874
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1875
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1876
  // Admission control - verify preconditions for spinning
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1877
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1878
  // We always spin a little bit, just to prevent _SpinDuration == 0 from
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1879
  // becoming an absorbing state.  Put another way, we spin briefly to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1880
  // sample, just in case the system load, parallelism, contention, or lock
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1881
  // modality changed.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1882
  //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1883
  // Consider the following alternative:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1884
  // Periodically set _SpinDuration = _SpinLimit and try a long/full
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1885
  // spin attempt.  "Periodically" might mean after a tally of
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1886
  // the # of failed spin attempts (or iterations) reaches some threshold.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1887
  // This takes us into the realm of 1-out-of-N spinning, where we
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1888
  // hold the duration constant but vary the frequency.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1889
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1890
  ctr = _SpinDuration;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1891
  if (ctr < Knob_SpinBase) ctr = Knob_SpinBase;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1892
  if (ctr <= 0) return 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1893
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1894
  if (Knob_SuccRestrict && _succ != NULL) return 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1895
  if (Knob_OState && NotRunnable (Self, (Thread *) _owner)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1896
    TEVENT(Spin abort - notrunnable [TOP]);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1897
    return 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1898
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1899
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1900
  int MaxSpin = Knob_MaxSpinners;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1901
  if (MaxSpin >= 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1902
    if (_Spinner > MaxSpin) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1903
      TEVENT(Spin abort -- too many spinners);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1904
      return 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1905
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1906
    // Slightly racy, but benign ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1907
    Adjust(&_Spinner, 1);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1908
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1909
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1910
  // We're good to spin ... spin ingress.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1911
  // CONSIDER: use Prefetch::write() to avoid RTS->RTO upgrades
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1912
  // when preparing to LD...CAS _owner, etc and the CAS is likely
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1913
  // to succeed.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1914
  int hits    = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1915
  int msk     = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1916
  int caspty  = Knob_CASPenalty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1917
  int oxpty   = Knob_OXPenalty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1918
  int sss     = Knob_SpinSetSucc;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1919
  if (sss && _succ == NULL) _succ = Self;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1920
  Thread * prv = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1921
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1922
  // There are three ways to exit the following loop:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1923
  // 1.  A successful spin where this thread has acquired the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1924
  // 2.  Spin failure with prejudice
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1925
  // 3.  Spin failure without prejudice
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1926
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1927
  while (--ctr >= 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1928
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1929
    // Periodic polling -- Check for pending GC
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1930
    // Threads may spin while they're unsafe.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1931
    // We don't want spinning threads to delay the JVM from reaching
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1932
    // a stop-the-world safepoint or to steal cycles from GC.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1933
    // If we detect a pending safepoint we abort in order that
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1934
    // (a) this thread, if unsafe, doesn't delay the safepoint, and (b)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1935
    // this thread, if safe, doesn't steal cycles from GC.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1936
    // This is in keeping with the "no loitering in runtime" rule.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1937
    // We periodically check to see if there's a safepoint pending.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1938
    if ((ctr & 0xFF) == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1939
      if (SafepointSynchronize::do_call_back()) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1940
        TEVENT(Spin: safepoint);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1941
        goto Abort;           // abrupt spin egress
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1942
      }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1943
      if (Knob_UsePause & 1) SpinPause();
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1944
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1945
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1946
    if (Knob_UsePause & 2) SpinPause();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1947
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1948
    // Exponential back-off ...  Stay off the bus to reduce coherency traffic.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1949
    // This is useful on classic SMP systems, but is of less utility on
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1950
    // N1-style CMT platforms.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1951
    //
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1952
    // Trade-off: lock acquisition latency vs coherency bandwidth.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1953
    // Lock hold times are typically short.  A histogram
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1954
    // of successful spin attempts shows that we usually acquire
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1955
    // the lock early in the spin.  That suggests we want to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1956
    // sample _owner frequently in the early phase of the spin,
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1957
    // but then back-off and sample less frequently as the spin
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1958
    // progresses.  The back-off makes a good citizen on SMP big
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1959
    // SMP systems.  Oversampling _owner can consume excessive
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1960
    // coherency bandwidth.  Relatedly, if we _oversample _owner we
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1961
    // can inadvertently interfere with the the ST m->owner=null.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1962
    // executed by the lock owner.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1963
    if (ctr & msk) continue;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1964
    ++hits;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1965
    if ((hits & 0xF) == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1966
      // The 0xF, above, corresponds to the exponent.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1967
      // Consider: (msk+1)|msk
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1968
      msk = ((msk << 2)|3) & BackOffMask;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1969
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1970
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1971
    // Probe _owner with TATAS
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1972
    // If this thread observes the monitor transition or flicker
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1973
    // from locked to unlocked to locked, then the odds that this
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1974
    // thread will acquire the lock in this spin attempt go down
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1975
    // considerably.  The same argument applies if the CAS fails
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1976
    // or if we observe _owner change from one non-null value to
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1977
    // another non-null value.   In such cases we might abort
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1978
    // the spin without prejudice or apply a "penalty" to the
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1979
    // spin count-down variable "ctr", reducing it by 100, say.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1980
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1981
    Thread * ox = (Thread *) _owner;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1982
    if (ox == NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1983
      ox = (Thread *) Atomic::cmpxchg_ptr(Self, &_owner, NULL);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1984
      if (ox == NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1985
        // The CAS succeeded -- this thread acquired ownership
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1986
        // Take care of some bookkeeping to exit spin state.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1987
        if (sss && _succ == Self) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1988
          _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1989
        }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1990
        if (MaxSpin > 0) Adjust(&_Spinner, -1);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1991
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1992
        // Increase _SpinDuration :
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1993
        // The spin was successful (profitable) so we tend toward
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1994
        // longer spin attempts in the future.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1995
        // CONSIDER: factor "ctr" into the _SpinDuration adjustment.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1996
        // If we acquired the lock early in the spin cycle it
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  1997
        // makes sense to increase _SpinDuration proportionally.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  1998
        // Note that we don't clamp SpinDuration precisely at SpinLimit.
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  1999
        int x = _SpinDuration;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2000
        if (x < Knob_SpinLimit) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2001
          if (x < Knob_Poverty) x = Knob_Poverty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2002
          _SpinDuration = x + Knob_Bonus;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2003
        }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2004
        return 1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2005
      }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2006
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2007
      // The CAS failed ... we can take any of the following actions:
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2008
      // * penalize: ctr -= Knob_CASPenalty
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2009
      // * exit spin with prejudice -- goto Abort;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2010
      // * exit spin without prejudice.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2011
      // * Since CAS is high-latency, retry again immediately.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2012
      prv = ox;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2013
      TEVENT(Spin: cas failed);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2014
      if (caspty == -2) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2015
      if (caspty == -1) goto Abort;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2016
      ctr -= caspty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2017
      continue;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2018
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2019
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2020
    // Did lock ownership change hands ?
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2021
    if (ox != prv && prv != NULL) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2022
      TEVENT(spin: Owner changed)
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2023
      if (oxpty == -2) break;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2024
      if (oxpty == -1) goto Abort;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2025
      ctr -= oxpty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2026
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2027
    prv = ox;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2028
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2029
    // Abort the spin if the owner is not executing.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2030
    // The owner must be executing in order to drop the lock.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2031
    // Spinning while the owner is OFFPROC is idiocy.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2032
    // Consider: ctr -= RunnablePenalty ;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2033
    if (Knob_OState && NotRunnable (Self, ox)) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2034
      TEVENT(Spin abort - notrunnable);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2035
      goto Abort;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2036
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2037
    if (sss && _succ == NULL) _succ = Self;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2038
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2039
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2040
  // Spin failed with prejudice -- reduce _SpinDuration.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2041
  // TODO: Use an AIMD-like policy to adjust _SpinDuration.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2042
  // AIMD is globally stable.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2043
  TEVENT(Spin failure);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2044
  {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2045
    int x = _SpinDuration;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2046
    if (x > 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2047
      // Consider an AIMD scheme like: x -= (x >> 3) + 100
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2048
      // This is globally sample and tends to damp the response.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2049
      x -= Knob_Penalty;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2050
      if (x < 0) x = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2051
      _SpinDuration = x;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2052
    }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2053
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2054
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2055
 Abort:
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2056
  if (MaxSpin >= 0) Adjust(&_Spinner, -1);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2057
  if (sss && _succ == Self) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2058
    _succ = NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2059
    // Invariant: after setting succ=null a contending thread
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2060
    // must recheck-retry _owner before parking.  This usually happens
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2061
    // in the normal usage of TrySpin(), but it's safest
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2062
    // to make TrySpin() as foolproof as possible.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2063
    OrderAccess::fence();
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2064
    if (TryLock(Self) > 0) return 1;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2065
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2066
  return 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2067
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2068
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2069
// NotRunnable() -- informed spinning
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2070
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2071
// Don't bother spinning if the owner is not eligible to drop the lock.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2072
// Peek at the owner's schedctl.sc_state and Thread._thread_values and
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2073
// spin only if the owner thread is _thread_in_Java or _thread_in_vm.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2074
// The thread must be runnable in order to drop the lock in timely fashion.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2075
// If the _owner is not runnable then spinning will not likely be
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2076
// successful (profitable).
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2077
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2078
// Beware -- the thread referenced by _owner could have died
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2079
// so a simply fetch from _owner->_thread_state might trap.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2080
// Instead, we use SafeFetchXX() to safely LD _owner->_thread_state.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2081
// Because of the lifecycle issues the schedctl and _thread_state values
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2082
// observed by NotRunnable() might be garbage.  NotRunnable must
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2083
// tolerate this and consider the observed _thread_state value
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2084
// as advisory.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2085
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2086
// Beware too, that _owner is sometimes a BasicLock address and sometimes
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2087
// a thread pointer.
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2088
// Alternately, we might tag the type (thread pointer vs basiclock pointer)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2089
// with the LSB of _owner.  Another option would be to probablistically probe
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2090
// the putative _owner->TypeTag value.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2091
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2092
// Checking _thread_state isn't perfect.  Even if the thread is
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2093
// in_java it might be blocked on a page-fault or have been preempted
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2094
// and sitting on a ready/dispatch queue.  _thread state in conjunction
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2095
// with schedctl.sc_state gives us a good picture of what the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2096
// thread is doing, however.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2097
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2098
// TODO: check schedctl.sc_state.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2099
// We'll need to use SafeFetch32() to read from the schedctl block.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2100
// See RFE #5004247 and http://sac.sfbay.sun.com/Archives/CaseLog/arc/PSARC/2005/351/
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2101
//
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2102
// The return value from NotRunnable() is *advisory* -- the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2103
// result is based on sampling and is not necessarily coherent.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2104
// The caller must tolerate false-negative and false-positive errors.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2105
// Spinning, in general, is probabilistic anyway.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2106
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2107
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2108
int ObjectMonitor::NotRunnable(Thread * Self, Thread * ox) {
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2109
  // Check ox->TypeTag == 2BAD.
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2110
  if (ox == NULL) return 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2111
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2112
  // Avoid transitive spinning ...
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2113
  // Say T1 spins or blocks trying to acquire L.  T1._Stalled is set to L.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2114
  // Immediately after T1 acquires L it's possible that T2, also
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2115
  // spinning on L, will see L.Owner=T1 and T1._Stalled=L.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2116
  // This occurs transiently after T1 acquired L but before
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2117
  // T1 managed to clear T1.Stalled.  T2 does not need to abort
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2118
  // its spin in this circumstance.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2119
  intptr_t BlockedOn = SafeFetchN((intptr_t *) &ox->_Stalled, intptr_t(1));
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2120
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2121
  if (BlockedOn == 1) return 1;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2122
  if (BlockedOn != 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2123
    return BlockedOn != intptr_t(this) && _owner == ox;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2124
  }
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2125
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2126
  assert(sizeof(((JavaThread *)ox)->_thread_state == sizeof(int)), "invariant");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2127
  int jst = SafeFetch32((int *) &((JavaThread *) ox)->_thread_state, -1);;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2128
  // consider also: jst != _thread_in_Java -- but that's overspecific.
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2129
  return jst == _thread_blocked || jst == _thread_in_native;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2130
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2131
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2132
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2133
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2134
// WaitSet management ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2135
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2136
ObjectWaiter::ObjectWaiter(Thread* thread) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2137
  _next     = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2138
  _prev     = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2139
  _notified = 0;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2140
  TState    = TS_RUN;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2141
  _thread   = thread;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2142
  _event    = thread->_ParkEvent;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2143
  _active   = false;
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2144
  assert(_event != NULL, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2145
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2146
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  2147
void ObjectWaiter::wait_reenter_begin(ObjectMonitor * const mon) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2148
  JavaThread *jt = (JavaThread *)this->_thread;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2149
  _active = JavaThreadBlockedOnMonitorEnterState::wait_reenter_begin(jt, mon);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2150
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2151
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  2152
void ObjectWaiter::wait_reenter_end(ObjectMonitor * const mon) {
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2153
  JavaThread *jt = (JavaThread *)this->_thread;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2154
  JavaThreadBlockedOnMonitorEnterState::wait_reenter_end(jt, _active);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2155
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2156
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2157
inline void ObjectMonitor::AddWaiter(ObjectWaiter* node) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2158
  assert(node != NULL, "should not add NULL node");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2159
  assert(node->_prev == NULL, "node already in list");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2160
  assert(node->_next == NULL, "node already in list");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2161
  // put node at end of queue (circular doubly linked list)
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2162
  if (_WaitSet == NULL) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2163
    _WaitSet = node;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2164
    node->_prev = node;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2165
    node->_next = node;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2166
  } else {
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2167
    ObjectWaiter* head = _WaitSet;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2168
    ObjectWaiter* tail = head->_prev;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2169
    assert(tail->_next == head, "invariant check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2170
    tail->_next = node;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2171
    head->_prev = node;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2172
    node->_next = head;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2173
    node->_prev = tail;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2174
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2175
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2176
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2177
inline ObjectWaiter* ObjectMonitor::DequeueWaiter() {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2178
  // dequeue the very first waiter
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2179
  ObjectWaiter* waiter = _WaitSet;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2180
  if (waiter) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2181
    DequeueSpecificWaiter(waiter);
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2182
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2183
  return waiter;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2184
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2185
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2186
inline void ObjectMonitor::DequeueSpecificWaiter(ObjectWaiter* node) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2187
  assert(node != NULL, "should not dequeue NULL node");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2188
  assert(node->_prev != NULL, "node already removed from list");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2189
  assert(node->_next != NULL, "node already removed from list");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2190
  // when the waiter has woken up because of interrupt,
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2191
  // timeout or other spurious wake-up, dequeue the
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2192
  // waiter from waiting list
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2193
  ObjectWaiter* next = node->_next;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2194
  if (next == node) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2195
    assert(node->_prev == node, "invariant check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2196
    _WaitSet = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2197
  } else {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2198
    ObjectWaiter* prev = node->_prev;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2199
    assert(prev->_next == node, "invariant check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2200
    assert(next->_prev == node, "invariant check");
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2201
    next->_prev = prev;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2202
    prev->_next = next;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2203
    if (_WaitSet == node) {
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2204
      _WaitSet = next;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2205
    }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2206
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2207
  node->_next = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2208
  node->_prev = NULL;
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2209
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2210
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2211
// -----------------------------------------------------------------------------
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2212
// PerfData support
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2213
PerfCounter * ObjectMonitor::_sync_ContendedLockAttempts       = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2214
PerfCounter * ObjectMonitor::_sync_FutileWakeups               = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2215
PerfCounter * ObjectMonitor::_sync_Parks                       = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2216
PerfCounter * ObjectMonitor::_sync_EmptyNotifications          = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2217
PerfCounter * ObjectMonitor::_sync_Notifications               = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2218
PerfCounter * ObjectMonitor::_sync_PrivateA                    = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2219
PerfCounter * ObjectMonitor::_sync_PrivateB                    = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2220
PerfCounter * ObjectMonitor::_sync_SlowExit                    = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2221
PerfCounter * ObjectMonitor::_sync_SlowEnter                   = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2222
PerfCounter * ObjectMonitor::_sync_SlowNotify                  = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2223
PerfCounter * ObjectMonitor::_sync_SlowNotifyAll               = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2224
PerfCounter * ObjectMonitor::_sync_FailedSpins                 = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2225
PerfCounter * ObjectMonitor::_sync_SuccessfulSpins             = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2226
PerfCounter * ObjectMonitor::_sync_MonInCirculation            = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2227
PerfCounter * ObjectMonitor::_sync_MonScavenged                = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2228
PerfCounter * ObjectMonitor::_sync_Inflations                  = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2229
PerfCounter * ObjectMonitor::_sync_Deflations                  = NULL;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2230
PerfLongVariable * ObjectMonitor::_sync_MonExtant              = NULL;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2231
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2232
// One-shot global initialization for the sync subsystem.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2233
// We could also defer initialization and initialize on-demand
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2234
// the first time we call inflate().  Initialization would
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2235
// be protected - like so many things - by the MonitorCache_lock.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2236
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2237
void ObjectMonitor::Initialize() {
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2238
  static int InitializationCompleted = 0;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2239
  assert(InitializationCompleted == 0, "invariant");
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2240
  InitializationCompleted = 1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2241
  if (UsePerfData) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2242
    EXCEPTION_MARK;
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2243
#define NEWPERFCOUNTER(n)                                                \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2244
  {                                                                      \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2245
    n = PerfDataManager::create_counter(SUN_RT, #n, PerfData::U_Events,  \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2246
                                        CHECK);                          \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2247
  }
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2248
#define NEWPERFVARIABLE(n)                                                \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2249
  {                                                                       \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2250
    n = PerfDataManager::create_variable(SUN_RT, #n, PerfData::U_Events,  \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2251
                                         CHECK);                          \
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2252
  }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2253
    NEWPERFCOUNTER(_sync_Inflations);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2254
    NEWPERFCOUNTER(_sync_Deflations);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2255
    NEWPERFCOUNTER(_sync_ContendedLockAttempts);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2256
    NEWPERFCOUNTER(_sync_FutileWakeups);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2257
    NEWPERFCOUNTER(_sync_Parks);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2258
    NEWPERFCOUNTER(_sync_EmptyNotifications);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2259
    NEWPERFCOUNTER(_sync_Notifications);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2260
    NEWPERFCOUNTER(_sync_SlowEnter);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2261
    NEWPERFCOUNTER(_sync_SlowExit);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2262
    NEWPERFCOUNTER(_sync_SlowNotify);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2263
    NEWPERFCOUNTER(_sync_SlowNotifyAll);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2264
    NEWPERFCOUNTER(_sync_FailedSpins);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2265
    NEWPERFCOUNTER(_sync_SuccessfulSpins);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2266
    NEWPERFCOUNTER(_sync_PrivateA);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2267
    NEWPERFCOUNTER(_sync_PrivateB);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2268
    NEWPERFCOUNTER(_sync_MonInCirculation);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2269
    NEWPERFCOUNTER(_sync_MonScavenged);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2270
    NEWPERFVARIABLE(_sync_MonExtant);
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2271
#undef NEWPERFCOUNTER
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2272
#undef NEWPERFVARIABLE
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2273
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2274
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2275
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2276
static char * kvGet(char * kvList, const char * Key) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2277
  if (kvList == NULL) return NULL;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2278
  size_t n = strlen(Key);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2279
  char * Search;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2280
  for (Search = kvList; *Search; Search += strlen(Search) + 1) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2281
    if (strncmp (Search, Key, n) == 0) {
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2282
      if (Search[n] == '=') return Search + n + 1;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2283
      if (Search[n] == 0)   return(char *) "1";
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2284
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2285
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2286
  return NULL;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2287
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2288
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2289
static int kvGetInt(char * kvList, const char * Key, int Default) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2290
  char * v = kvGet(kvList, Key);
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2291
  int rslt = v ? ::strtol(v, NULL, 0) : Default;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2292
  if (Knob_ReportSettings && v != NULL) {
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2293
    tty->print_cr("INFO: SyncKnob: %s %d(%d)", Key, rslt, Default) ;
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2294
    tty->flush();
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2295
  }
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2296
  return rslt;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2297
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2298
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2299
void ObjectMonitor::DeferredInitialize() {
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2300
  if (InitDone > 0) return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2301
  if (Atomic::cmpxchg (-1, &InitDone, 0) != 0) {
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2302
    while (InitDone != 1) /* empty */;
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2303
    return;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2304
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2305
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2306
  // One-shot global initialization ...
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2307
  // The initialization is idempotent, so we don't need locks.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2308
  // In the future consider doing this via os::init_2().
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2309
  // SyncKnobs consist of <Key>=<Value> pairs in the style
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2310
  // of environment variables.  Start by converting ':' to NUL.
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2311
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2312
  if (SyncKnobs == NULL) SyncKnobs = "";
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2313
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2314
  size_t sz = strlen(SyncKnobs);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2315
  char * knobs = (char *) malloc(sz + 2);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2316
  if (knobs == NULL) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2317
    vm_exit_out_of_memory(sz + 2, OOM_MALLOC_ERROR, "Parse SyncKnobs");
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2318
    guarantee(0, "invariant");
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2319
  }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2320
  strcpy(knobs, SyncKnobs);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2321
  knobs[sz+1] = 0;
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2322
  for (char * p = knobs; *p; p++) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2323
    if (*p == ':') *p = 0;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2324
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2325
26684
d1221849ea3d 8057109: manual cleanup of white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 26683
diff changeset
  2326
  #define SETKNOB(x) { Knob_##x = kvGetInt(knobs, #x, Knob_##x); }
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2327
  SETKNOB(ReportSettings);
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2328
  SETKNOB(ExitRelease);
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2329
  SETKNOB(Verbose);
25472
381638db28e6 8047104: cleanup misc issues prior to Contended Locking reorder and cache
dcubed
parents: 25468
diff changeset
  2330
  SETKNOB(VerifyInUse);
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2331
  SETKNOB(VerifyMatch);
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2332
  SETKNOB(FixedSpin);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2333
  SETKNOB(SpinLimit);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2334
  SETKNOB(SpinBase);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2335
  SETKNOB(SpinBackOff);
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2336
  SETKNOB(CASPenalty);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2337
  SETKNOB(OXPenalty);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2338
  SETKNOB(LogSpins);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2339
  SETKNOB(SpinSetSucc);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2340
  SETKNOB(SuccEnabled);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2341
  SETKNOB(SuccRestrict);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2342
  SETKNOB(Penalty);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2343
  SETKNOB(Bonus);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2344
  SETKNOB(BonusB);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2345
  SETKNOB(Poverty);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2346
  SETKNOB(SpinAfterFutile);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2347
  SETKNOB(UsePause);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2348
  SETKNOB(SpinEarly);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2349
  SETKNOB(OState);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2350
  SETKNOB(MaxSpinners);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2351
  SETKNOB(PreSpin);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2352
  SETKNOB(ExitPolicy);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2353
  SETKNOB(QMode);
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2354
  SETKNOB(ResetEvent);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2355
  SETKNOB(MoveNotifyee);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2356
  SETKNOB(FastHSSEC);
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2357
  #undef SETKNOB
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2358
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2359
  if (Knob_Verbose) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2360
    sanity_checks();
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2361
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2362
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2363
  if (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
  2364
    BackOffMask = (1 << Knob_SpinBackOff) - 1;
31782
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2365
    if (Knob_ReportSettings) {
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2366
      tty->print_cr("INFO: BackOffMask=0x%X", BackOffMask);
b23b74f8ae8d 8130448: thread dump improvements, comment additions, new diagnostics inspired by 8077392
dcubed
parents: 27165
diff changeset
  2367
    }
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2368
    // CONSIDER: BackOffMask = ROUNDUP_NEXT_POWER2 (ncpus-1)
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2369
  } else {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2370
    Knob_SpinLimit = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2371
    Knob_SpinBase  = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2372
    Knob_PreSpin   = 0;
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2373
    Knob_FixedSpin = -1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2374
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2375
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2376
  if (Knob_LogSpins == 0) {
26683
a02753d5a0b2 8057107: cleanup indent white space issues prior to Contended Locking reorder and cache line bucket
dcubed
parents: 25633
diff changeset
  2377
    ObjectMonitor::_sync_FailedSpins = NULL;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2378
  }
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2379
25064
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2380
  free(knobs);
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2381
  OrderAccess::fence();
244218e6ec0a 8046758: cleanup non-indent white space issues prior to Contended Locking cleanup bucket
dcubed
parents: 24832
diff changeset
  2382
  InitDone = 1;
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2383
}
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2384
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2385
void ObjectMonitor::sanity_checks() {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2386
  int error_cnt = 0;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2387
  int warning_cnt = 0;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2388
  bool verbose = Knob_Verbose != 0 NOT_PRODUCT(|| VerboseInternalVMTests);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2389
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2390
  if (verbose) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2391
    tty->print_cr("INFO: sizeof(ObjectMonitor)=" SIZE_FORMAT,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2392
                  sizeof(ObjectMonitor));
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2393
    tty->print_cr("INFO: sizeof(PaddedEnd<ObjectMonitor>)=" SIZE_FORMAT,
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2394
                  sizeof(PaddedEnd<ObjectMonitor>));
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2395
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2396
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2397
  uint cache_line_size = VM_Version::L1_data_cache_line_size();
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2398
  if (verbose) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2399
    tty->print_cr("INFO: L1_data_cache_line_size=%u", cache_line_size);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2400
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2401
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2402
  ObjectMonitor dummy;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2403
  u_char *addr_begin  = (u_char*)&dummy;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2404
  u_char *addr_header = (u_char*)&dummy._header;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2405
  u_char *addr_owner  = (u_char*)&dummy._owner;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2406
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2407
  uint offset_header = (uint)(addr_header - addr_begin);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2408
  if (verbose) tty->print_cr("INFO: offset(_header)=%u", offset_header);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2409
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2410
  uint offset_owner = (uint)(addr_owner - addr_begin);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2411
  if (verbose) tty->print_cr("INFO: offset(_owner)=%u", offset_owner);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2412
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2413
  if ((uint)(addr_header - addr_begin) != 0) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2414
    tty->print_cr("ERROR: offset(_header) must be zero (0).");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2415
    error_cnt++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2416
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2417
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2418
  if (cache_line_size != 0) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2419
    // 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: 25472
diff changeset
  2420
    // do some cache line specific sanity checks
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2421
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2422
    if ((offset_owner - offset_header) < cache_line_size) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2423
      tty->print_cr("WARNING: the _header and _owner fields are closer "
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2424
                    "than a cache line which permits false sharing.");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2425
      warning_cnt++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2426
    }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2427
27165
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2428
    if ((sizeof(PaddedEnd<ObjectMonitor>) % cache_line_size) != 0) {
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2429
      tty->print_cr("WARNING: PaddedEnd<ObjectMonitor> size is not a "
785a8d56024c 8049737: Contended Locking reorder and cache line bucket
dcubed
parents: 26684
diff changeset
  2430
                    "multiple of a cache line which permits false sharing.");
25633
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2431
      warning_cnt++;
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2432
    }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2433
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2434
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2435
  ObjectSynchronizer::sanity_checks(verbose, cache_line_size, &error_cnt,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2436
                                    &warning_cnt);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2437
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2438
  if (verbose || error_cnt != 0 || warning_cnt != 0) {
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2439
    tty->print_cr("INFO: error_cnt=%d", error_cnt);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2440
    tty->print_cr("INFO: warning_cnt=%d", warning_cnt);
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2441
  }
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2442
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2443
  guarantee(error_cnt == 0,
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2444
            "Fatal error(s) found in ObjectMonitor::sanity_checks()");
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2445
}
4cd9c4622c8c 8049717: expose L1_data_cache_line_size for diagnostic/sanity checks
dcubed
parents: 25472
diff changeset
  2446
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2447
#ifndef PRODUCT
35529
39376b4613b5 8147012: Fix includes in internalVMTests.cpp
ehelin
parents: 32622
diff changeset
  2448
void ObjectMonitor_test() {
39376b4613b5 8147012: Fix includes in internalVMTests.cpp
ehelin
parents: 32622
diff changeset
  2449
  ObjectMonitor::sanity_checks();
39376b4613b5 8147012: Fix includes in internalVMTests.cpp
ehelin
parents: 32622
diff changeset
  2450
}
6975
dc9b63952682 6988353: refactor contended sync subsystem
acorn
parents:
diff changeset
  2451
#endif