src/hotspot/share/runtime/vm_operations.cpp
author stuefe
Sun, 11 Mar 2018 07:11:03 +0100
changeset 49389 9ef2eee8ca7c
parent 48105 8d15b1369c7a
child 49449 ef5d5d343e2a
permissions -rw-r--r--
8199430: Rename MetaspaceAux to something more meaningful Reviewed-by: zgu, coleenp
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
47802
18dccdc438d7 8189688: NMT: Report per-class load metadata information
zgu
parents: 47216
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4750
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4750
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4750
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    25
#include "precompiled.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    26
#include "classfile/symbolTable.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    27
#include "classfile/vmSymbols.hpp"
25715
d5a8dbdc5150 8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents: 25057
diff changeset
    28
#include "code/codeCache.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    29
#include "compiler/compileBroker.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29071
diff changeset
    30
#include "gc/shared/isGCActiveMark.hpp"
34262
43560e879d6d 8143157: Convert TraceVMOperation to Unified Logging
rprotacio
parents: 33451
diff changeset
    31
#include "logging/log.hpp"
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    32
#include "logging/logStream.hpp"
29071
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
    33
#include "memory/heapInspection.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    34
#include "memory/resourceArea.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
    35
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    36
#include "runtime/arguments.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    37
#include "runtime/deoptimization.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    38
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    39
#include "runtime/sweeper.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 10565
diff changeset
    40
#include "runtime/thread.inline.hpp"
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
    41
#include "runtime/threadSMR.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    42
#include "runtime/vm_operations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 7106
diff changeset
    43
#include "services/threadService.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    44
#include "trace/tracing.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
#define VM_OP_NAME_INITIALIZE(name) #name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
const char* VM_Operation::_names[VM_Operation::VMOp_Terminating] = \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  { VM_OPS_DO(VM_OP_NAME_INITIALIZE) };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
void VM_Operation::set_calling_thread(Thread* thread, ThreadPriority priority) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  _calling_thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  _priority = priority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
void VM_Operation::evaluate() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  ResourceMark rm;
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    60
  LogTarget(Debug, vmoperation) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    61
  if (lt.is_enabled()) {
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    62
    LogStream ls(lt);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    63
    ls.print("begin ");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    64
    print_on_error(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    65
    ls.cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  doit();
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    68
  if (lt.is_enabled()) {
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    69
    LogStream ls(lt);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    70
    ls.print("end ");
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    71
    print_on_error(&ls);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 42664
diff changeset
    72
    ls.cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    76
const char* VM_Operation::mode_to_string(Mode mode) {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    77
  switch(mode) {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    78
    case _safepoint      : return "safepoint";
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    79
    case _no_safepoint   : return "no safepoint";
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    80
    case _concurrent     : return "concurrent";
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    81
    case _async_safepoint: return "async safepoint";
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    82
    default              : return "unknown";
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    83
  }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    84
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// Called by fatal error handler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
void VM_Operation::print_on_error(outputStream* st) const {
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 32401
diff changeset
    87
  st->print("VM_Operation (" PTR_FORMAT "): ", p2i(this));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  st->print("%s", name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16680
diff changeset
    90
  const char* mode = mode_to_string(evaluation_mode());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  st->print(", mode: %s", mode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  if (calling_thread()) {
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 32401
diff changeset
    94
    st->print(", requested by thread " PTR_FORMAT, p2i(calling_thread()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
void VM_ThreadStop::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   100
  ThreadsListHandle tlh;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  JavaThread* target = java_lang_Thread::thread(target_thread());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Note that this now allows multiple ThreadDeath exceptions to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // thrown at a thread.
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   104
  if (target != NULL && (!EnableThreadSMRExtraValidityChecks || tlh.includes(target))) {
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   105
    // The target thread has run and has not exited yet.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    target->send_thread_stop(throwable());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
37289
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   110
void VM_ClearICs::doit() {
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   111
  if (_preserve_static_stubs) {
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   112
    CodeCache::cleanup_inline_caches();
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   113
  } else {
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   114
    CodeCache::clear_inline_caches();
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   115
  }
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   116
}
9989add27bf4 8067247: Crash: assert(method_holder->data() == 0 ...) failed: a) MT-unsafe modification of inline cache
jcm
parents: 36322
diff changeset
   117
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
void VM_Deoptimize::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // We do not want any GCs to happen while we are in the middle of this VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  DeoptimizationMarker dm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // Deoptimize all activations depending on marked nmethods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  Deoptimization::deoptimize_dependents();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
32401
cc58aeaec340 8075805: Crash while trying to release CompiledICHolder
thartmann
parents: 31620
diff changeset
   126
  // Make the dependent methods not entrant
cc58aeaec340 8075805: Crash while trying to release CompiledICHolder
thartmann
parents: 31620
diff changeset
   127
  CodeCache::make_marked_nmethods_not_entrant();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
27420
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 26587
diff changeset
   130
void VM_MarkActiveNMethods::doit() {
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 26587
diff changeset
   131
  NMethodSweeper::mark_active_nmethods();
04e6f914cce1 8046809: vm/mlvm/meth/stress/compiler/deoptimize CodeCache is full.
anoll
parents: 26587
diff changeset
   132
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32401
diff changeset
   134
VM_DeoptimizeFrame::VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id, int reason) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  _thread = thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  _id     = id;
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32401
diff changeset
   137
  _reason = reason;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
void VM_DeoptimizeFrame::doit() {
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32401
diff changeset
   142
  assert(_reason > Deoptimization::Reason_none && _reason < Deoptimization::Reason_LIMIT, "invalid deopt reason");
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32401
diff changeset
   143
  Deoptimization::deoptimize_frame_internal(_thread, _id, (Deoptimization::DeoptReason)_reason);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
void VM_DeoptimizeAll::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  DeoptimizationMarker dm;
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   151
  JavaThreadIteratorWithHandle jtiwh;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // deoptimize all java threads in the system
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  if (DeoptimizeALot) {
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   154
    for (; JavaThread *thread = jtiwh.next(); ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
      if (thread->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
        thread->deoptimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  } else if (DeoptimizeRandom) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    // Deoptimize some selected threads and frames
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    int tnum = os::random() & 0x3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    int fnum =  os::random() & 0x3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    int tcount = 0;
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   165
    for (; JavaThread *thread = jtiwh.next(); ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
      if (thread->has_last_Java_frame()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
        if (tcount++ == tnum)  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
        tcount = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
          int fcount = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
          // Deoptimize some selected frames.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
          // Biased llocking wants a updated register map
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
          for(StackFrameStream fst(thread, UseBiasedLocking); !fst.is_done(); fst.next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
            if (fst.current()->can_be_deoptimized()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
              if (fcount++ == fnum) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
                fcount = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
                Deoptimization::deoptimize(thread, *fst.current(), fst.register_map());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
void VM_ZombieAll::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  JavaThread *thread = (JavaThread *)calling_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  assert(thread->is_Java_thread(), "must be a Java thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  thread->make_zombies();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
#endif // !PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   195
void VM_UnlinkSymbols::doit() {
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   196
  JavaThread *thread = (JavaThread *)calling_thread();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   197
  assert(thread->is_Java_thread(), "must be a Java thread");
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   198
  SymbolTable::unlink();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   199
}
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7397
diff changeset
   200
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
void VM_Verify::doit() {
16680
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 14583
diff changeset
   202
  Universe::heap()->prepare_for_verify();
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 34633
diff changeset
   203
  Universe::verify();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
bool VM_PrintThreads::doit_prologue() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  // Make sure AbstractOwnableSynchronizer is loaded
38708
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   208
  JavaThread* jt = JavaThread::current();
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   209
  java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(jt);
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   210
  if (jt->has_pending_exception()) {
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   211
    return false;
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   212
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  // Get Heap_lock if concurrent locks will be dumped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  if (_print_concurrent_locks) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    Heap_lock->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
void VM_PrintThreads::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  Threads::print_on(_out, true, false, _print_concurrent_locks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
void VM_PrintThreads::doit_epilogue() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  if (_print_concurrent_locks) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    // Release Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    Heap_lock->unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
void VM_PrintJNI::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  JNIHandles::print_on(_out);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
47802
18dccdc438d7 8189688: NMT: Report per-class load metadata information
zgu
parents: 47216
diff changeset
   236
void VM_PrintMetadata::doit() {
49389
9ef2eee8ca7c 8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents: 48105
diff changeset
   237
  MetaspaceUtils::print_metadata_for_nmt(_out, _scale);
47802
18dccdc438d7 8189688: NMT: Report per-class load metadata information
zgu
parents: 47216
diff changeset
   238
}
18dccdc438d7 8189688: NMT: Report per-class load metadata information
zgu
parents: 47216
diff changeset
   239
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
VM_FindDeadlocks::~VM_FindDeadlocks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  if (_deadlocks != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    DeadlockCycle* cycle = _deadlocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    while (cycle != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
      DeadlockCycle* d = cycle;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
      cycle = cycle->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
      delete d;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
bool VM_FindDeadlocks::doit_prologue() {
25057
f38210f84f8c 8031819: Remove legacy jdk checks and code
hseigel
parents: 24424
diff changeset
   252
  if (_concurrent_locks) {
38708
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   253
    // Make sure AbstractOwnableSynchronizer is loaded
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   254
    JavaThread* jt = JavaThread::current();
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   255
    java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(jt);
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   256
    if (jt->has_pending_exception()) {
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   257
      return false;
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   258
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
void VM_FindDeadlocks::doit() {
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   265
  // Update the hazard ptr in the originating thread to the current
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   266
  // list of threads. This VM operation needs the current list of
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   267
  // threads for proper deadlock detection and those are the
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   268
  // JavaThreads we need to be protected when we return info to the
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   269
  // originating thread.
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   270
  _setter.set();
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   271
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   272
  _deadlocks = ThreadService::find_deadlocks_at_safepoint(_setter.list(), _concurrent_locks);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  if (_out != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    int num_deadlocks = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    for (DeadlockCycle* cycle = _deadlocks; cycle != NULL; cycle = cycle->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
      num_deadlocks++;
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   277
      cycle->print_on_with(_setter.list(), _out);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    if (num_deadlocks == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
      _out->print_cr("\nFound 1 deadlock.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
      _out->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    } else if (num_deadlocks > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      _out->print_cr("\nFound %d deadlocks.\n", num_deadlocks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      _out->flush();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
                             int max_depth,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
                             bool with_locked_monitors,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
                             bool with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  _result = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  _num_threads = 0; // 0 indicates all threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  _threads = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  _result = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  _max_depth = max_depth;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  _with_locked_monitors = with_locked_monitors;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  _with_locked_synchronizers = with_locked_synchronizers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
                             GrowableArray<instanceHandle>* threads,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
                             int num_threads,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
                             int max_depth,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
                             bool with_locked_monitors,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
                             bool with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  _result = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  _num_threads = num_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  _threads = threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  _result = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  _max_depth = max_depth;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  _with_locked_monitors = with_locked_monitors;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  _with_locked_synchronizers = with_locked_synchronizers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
bool VM_ThreadDump::doit_prologue() {
38708
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   319
  // Make sure AbstractOwnableSynchronizer is loaded
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   320
  JavaThread* jt = JavaThread::current();
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   321
  java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(jt);
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   322
  if (jt->has_pending_exception()) {
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   323
    return false;
8c27a4f8b242 8154589: assert(k != NULL) failed: preloaded klass not initialized
dholmes
parents: 37296
diff changeset
   324
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  if (_with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    // Acquire Heap_lock to dump concurrent locks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    Heap_lock->lock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
void VM_ThreadDump::doit_epilogue() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  if (_with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    // Release Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    Heap_lock->unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
void VM_ThreadDump::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   344
  // Set the hazard ptr in the originating thread to protect the
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   345
  // current list of threads. This VM operation needs the current list
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   346
  // of threads for a proper dump and those are the JavaThreads we need
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   347
  // to be protected when we return info to the originating thread.
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   348
  _result->set_t_list();
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   349
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  ConcurrentLocksDump concurrent_locks(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  if (_with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    concurrent_locks.dump_at_safepoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  if (_num_threads == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    // Snapshot all live threads
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   357
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   358
    for (uint i = 0; i < _result->t_list()->length(); i++) {
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   359
      JavaThread* jt = _result->t_list()->thread_at(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
      if (jt->is_exiting() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
          jt->is_hidden_from_external_view())  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
        // skip terminating threads and hidden threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
      ThreadConcurrentLocks* tcl = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
      if (_with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
        tcl = concurrent_locks.thread_concurrent_locks(jt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
      ThreadSnapshot* ts = snapshot_thread(jt, tcl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
      _result->add_thread_snapshot(ts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    // Snapshot threads in the given _threads array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    // A dummy snapshot is created if a thread doesn't exist
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   375
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    for (int i = 0; i < _num_threads; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
      instanceHandle th = _threads->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
      if (th() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
        // skip if the thread doesn't exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
        // Add a dummy snapshot
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
        _result->add_thread_snapshot(new ThreadSnapshot());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
      // Dump thread stack only if the thread is alive and not exiting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
      // and not VM internal thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
      JavaThread* jt = java_lang_Thread::thread(th());
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   388
      if (jt != NULL && !_result->t_list()->includes(jt)) {
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   389
        // _threads[i] doesn't refer to a valid JavaThread; this check
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   390
        // is primarily for JVM_DumpThreads() which doesn't have a good
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   391
        // way to validate the _threads array.
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   392
        jt = NULL;
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   393
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      if (jt == NULL || /* thread not alive */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
          jt->is_exiting() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
          jt->is_hidden_from_external_view())  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
        // add a NULL snapshot if skipped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
        _result->add_thread_snapshot(new ThreadSnapshot());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
        continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
      ThreadConcurrentLocks* tcl = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      if (_with_locked_synchronizers) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
        tcl = concurrent_locks.thread_concurrent_locks(jt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
      ThreadSnapshot* ts = snapshot_thread(jt, tcl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
      _result->add_thread_snapshot(ts);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
ThreadSnapshot* VM_ThreadDump::snapshot_thread(JavaThread* java_thread, ThreadConcurrentLocks* tcl) {
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   412
  ThreadSnapshot* snapshot = new ThreadSnapshot(_result->t_list(), java_thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  snapshot->dump_stack_at_safepoint(_max_depth, _with_locked_monitors);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  snapshot->set_concurrent_locks(tcl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  return snapshot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
volatile bool VM_Exit::_vm_exited = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
Thread * VM_Exit::_shutdown_thread = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
int VM_Exit::set_vm_exited() {
31620
53be635ad49c 8087333: Optionally Pre-Generate the HotSpot Template Interpreter
bdelsart
parents: 30764
diff changeset
   422
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34262
diff changeset
   423
  Thread * thr_cur = Thread::current();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  int num_active = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  _shutdown_thread = thr_cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  _vm_exited = true;                                // global flag
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   431
  for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
      ++num_active;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
      thr->set_terminated(JavaThread::_vm_exited);  // per-thread flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    }
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   436
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  return num_active;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
int VM_Exit::wait_for_threads_in_native_to_block() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  // VM exits at safepoint. This function must be called at the final safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // to wait for threads in _thread_in_native state to be quiescent.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34262
diff changeset
   446
  Thread * thr_cur = Thread::current();
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27420
diff changeset
   447
  Monitor timer(Mutex::leaf, "VM_Exit timer", true,
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27420
diff changeset
   448
                Monitor::_safepoint_check_never);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // Compiler threads need longer wait because they can access VM data directly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // while in native. If they are active and some structures being used are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  // deleted by the shutdown sequence, they will crash. On the other hand, user
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  // threads must go through native=>Java/VM transitions first to access VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // data, and they will be stopped during state transition. In theory, we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  // don't have to wait for user threads to be quiescent, but it's always
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  // better to terminate VM when current thread is the only active thread, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  // wait for user threads too. Numbers are in 10 milliseconds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  int max_wait_user_thread = 30;                  // at least 300 milliseconds
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  int max_wait_compiler_thread = 1000;            // at least 10 seconds
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  int max_wait = max_wait_compiler_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  int attempts = 0;
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   464
  JavaThreadIteratorWithHandle jtiwh;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  while (true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    int num_active = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    int num_active_compiler_thread = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   469
    jtiwh.rewind();
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47802
diff changeset
   470
    for (; JavaThread *thr = jtiwh.next(); ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
      if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
        num_active++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
        if (thr->is_Compiler_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
          num_active_compiler_thread++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    if (num_active == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
       return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    } else if (attempts > max_wait) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
       return num_active;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    } else if (num_active_compiler_thread == 0 && attempts > max_wait_user_thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
       return num_active;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
    attempts++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    MutexLockerEx ml(&timer, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    timer.wait(Mutex::_no_safepoint_check_flag, 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
void VM_Exit::doit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  CompileBroker::set_should_block();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // Wait for a short period for threads in native to block. Any thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  // still executing native code after the wait will be stopped at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  // native==>Java/VM barriers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // Among 16276 JCK tests, 94% of them come here without any threads still
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  // running in native; the other 6% are quiescent within 250ms (Ultra 80).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  wait_for_threads_in_native_to_block();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  set_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // cleanup globals resources before exiting. exit_globals() currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // cleans up outputStream resources and PerfMemory resources.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  exit_globals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // Check for exit hook
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  exit_hook_t exit_hook = Arguments::exit_hook();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  if (exit_hook != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
    // exit hook should exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    exit_hook(_exit_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    // ... but if it didn't, we must do it here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    vm_direct_exit(_exit_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    vm_direct_exit(_exit_code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
void VM_Exit::wait_if_vm_exited() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  if (_vm_exited &&
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34262
diff changeset
   525
      Thread::current_or_null() != _shutdown_thread) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    // _vm_exited is set at safepoint, and the Threads_lock is never released
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    // we will block here until the process dies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    Threads_lock->lock_without_safepoint_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
}
26587
e8b28fa936af 8054889: Compiler team's implementation task
neliasso
parents: 25715
diff changeset
   532
36322
218528915a61 8149789: SIGSEGV in CompileTask::print
neliasso
parents: 35825
diff changeset
   533
void VM_PrintCompileQueue::doit() {
218528915a61 8149789: SIGSEGV in CompileTask::print
neliasso
parents: 35825
diff changeset
   534
  CompileBroker::print_compile_queues(_out);
218528915a61 8149789: SIGSEGV in CompileTask::print
neliasso
parents: 35825
diff changeset
   535
}
218528915a61 8149789: SIGSEGV in CompileTask::print
neliasso
parents: 35825
diff changeset
   536
29071
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
   537
#if INCLUDE_SERVICES
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
   538
void VM_PrintClassHierarchy::doit() {
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
   539
  KlassHierarchy::print_class_hierarchy(_out, _print_interfaces, _print_subclasses, _classname);
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
   540
}
73f45d04ad7a 8054888: Runtime: Add Diagnostic Command that prints the class hierarchy
cjplummer
parents: 28163
diff changeset
   541
#endif