src/hotspot/share/runtime/vmThread.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46732 hotspot/src/share/vm/runtime/vmThread.cpp@05423d4b10d2
child 49449 ef5d5d343e2a
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:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46496
diff changeset
     2
 * Copyright (c) 1998, 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: 5403
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
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: 5403
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: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "compiler/compileBroker.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29326
diff changeset
    27
#include "gc/shared/collectedHeap.hpp"
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
    28
#include "logging/log.hpp"
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
    29
#include "logging/logConfiguration.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "memory/resourceArea.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12379
diff changeset
    31
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "oops/oop.inline.hpp"
29084
1b732f2836ce 8073387: Move VerifyOopClosures out from genOopClosures.hpp
stefank
parents: 28163
diff changeset
    33
#include "oops/verifyOopClosure.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
#include "runtime/os.hpp"
37176
663bdc7d0b86 8149023: Event based tracing should cover safepoint begin and end
dsimms
parents: 36384
diff changeset
    37
#include "runtime/safepoint.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14582
diff changeset
    38
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "runtime/vm_operations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    41
#include "services/runtimeService.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
    42
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    43
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    44
#include "utilities/events.hpp"
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46496
diff changeset
    45
#include "utilities/vmError.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    46
#include "utilities/xmlstream.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// Dummy VM operation to act as first element in our circular double-linked list
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
class VM_Dummy: public VM_Operation {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  VMOp_Type type() const { return VMOp_Dummy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  void  doit() {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
VMOperationQueue::VMOperationQueue() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  // The queue is a circular doubled-linked list, which always contains
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  // one element (i.e., one element means empty).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  for(int i = 0; i < nof_priorities; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    _queue_length[i] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    _queue_counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    _queue[i] = new VM_Dummy();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
    _queue[i]->set_next(_queue[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    _queue[i]->set_prev(_queue[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  _drain_list = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
bool VMOperationQueue::queue_empty(int prio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  // It is empty if there is exactly one element
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  bool empty = (_queue[prio] == _queue[prio]->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  assert( (_queue_length[prio] == 0 && empty) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
          (_queue_length[prio] > 0  && !empty), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  return _queue_length[prio] == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
// Inserts an element to the right of the q element
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
void VMOperationQueue::insert(VM_Operation* q, VM_Operation* n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  assert(q->next()->prev() == q && q->prev()->next() == q, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  n->set_prev(q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  n->set_next(q->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  q->next()->set_prev(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  q->set_next(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
void VMOperationQueue::queue_add_front(int prio, VM_Operation *op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  _queue_length[prio]++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  insert(_queue[prio]->next(), op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
void VMOperationQueue::queue_add_back(int prio, VM_Operation *op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  _queue_length[prio]++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  insert(_queue[prio]->prev(), op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
void VMOperationQueue::unlink(VM_Operation* q) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  assert(q->next()->prev() == q && q->prev()->next() == q, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  q->prev()->set_next(q->next());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  q->next()->set_prev(q->prev());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
VM_Operation* VMOperationQueue::queue_remove_front(int prio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  if (queue_empty(prio)) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  assert(_queue_length[prio] >= 0, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  _queue_length[prio]--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  VM_Operation* r = _queue[prio]->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  assert(r != _queue[prio], "cannot remove base element");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  unlink(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  return r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
VM_Operation* VMOperationQueue::queue_drain(int prio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  if (queue_empty(prio)) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  DEBUG_ONLY(int length = _queue_length[prio];);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  assert(length >= 0, "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  _queue_length[prio] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  VM_Operation* r = _queue[prio]->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  assert(r != _queue[prio], "cannot remove base element");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  // remove links to base element from head and tail
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  r->set_prev(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  _queue[prio]->prev()->set_next(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // restore queue to empty state
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _queue[prio]->set_next(_queue[prio]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  _queue[prio]->set_prev(_queue[prio]);
5402
c51fd0c1d005 6888953: some calls to function-like macros are missing semicolons
jcoomes
parents: 5089
diff changeset
   125
  assert(queue_empty(prio), "drain corrupted queue");
17006
b9bfa72b7dda 7104565: trim jprt build targets
drchase
parents: 15235
diff changeset
   126
#ifdef ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  int len = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  VM_Operation* cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  for(cur = r; cur != NULL; cur=cur->next()) len++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  assert(len == length, "drain lost some ops");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  return r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
void VMOperationQueue::queue_oops_do(int queue, OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  VM_Operation* cur = _queue[queue];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  cur = cur->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  while (cur != _queue[queue]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    cur->oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
    cur = cur->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
void VMOperationQueue::drain_list_oops_do(OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  VM_Operation* cur = _drain_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  while (cur != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    cur->oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
    cur = cur->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
//-----------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// High-level interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
bool VMOperationQueue::add(VM_Operation *op) {
5089
0cce506a0158 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 4901
diff changeset
   155
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   156
  HOTSPOT_VMOPS_REQUEST(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   157
                   (char *) op->name(), strlen(op->name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   158
                   op->evaluation_mode());
5089
0cce506a0158 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 4901
diff changeset
   159
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // Encapsulates VM queue policy. Currently, that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // only involves putting them on the right list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  if (op->evaluate_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    queue_add_back(SafepointPriority, op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  queue_add_back(MediumPriority, op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
VM_Operation* VMOperationQueue::remove_next() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // Assuming VMOperation queue is two-level priority queue. If there are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // more than two priorities, we need a different scheduling algorithm.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  assert(SafepointPriority == 0 && MediumPriority == 1 && nof_priorities == 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
         "current algorithm does not work");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // simple counter based scheduling to prevent starvation of lower priority
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // queue. -- see 4390175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  int high_prio, low_prio;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  if (_queue_counter++ < 10) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      high_prio = SafepointPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      low_prio  = MediumPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      _queue_counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      high_prio = MediumPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
      low_prio  = SafepointPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  return queue_remove_front(queue_empty(high_prio) ? low_prio : high_prio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
void VMOperationQueue::oops_do(OopClosure* f) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  for(int i = 0; i < nof_priorities; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    queue_oops_do(i, f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  drain_list_oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
//------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
// Implementation of VMThread stuff
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
bool                VMThread::_should_terminate   = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
bool              VMThread::_terminated         = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
Monitor*          VMThread::_terminate_lock     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
VMThread*         VMThread::_vm_thread          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
VM_Operation*     VMThread::_cur_vm_operation   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
VMOperationQueue* VMThread::_vm_queue           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
PerfCounter*      VMThread::_perf_accumulated_vm_operation_time = NULL;
46496
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   210
const char*       VMThread::_no_op_reason       = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
void VMThread::create() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  assert(vm_thread() == NULL, "we can only allocate one VMThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  _vm_thread = new VMThread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // Create VM operation queue
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  _vm_queue = new VMOperationQueue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  guarantee(_vm_queue != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
28163
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27164
diff changeset
   221
  _terminate_lock = new Monitor(Mutex::safepoint, "VMThread::_terminate_lock", true,
322d55d167be 8047290: Make Mutex::_no_safepoint_check_flag locks verify that this lock never checks for safepoint
coleenp
parents: 27164
diff changeset
   222
                                Monitor::_safepoint_check_never);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    // jvmstat performance counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    Thread* THREAD = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    _perf_accumulated_vm_operation_time =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
                 PerfDataManager::create_counter(SUN_THREADS, "vmOperationTime",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
                                                 PerfData::U_Ticks, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
4489
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 3908
diff changeset
   233
VMThread::VMThread() : NamedThread() {
514173c9a0c2 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 3908
diff changeset
   234
  set_name("VM Thread");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
void VMThread::destroy() {
38290
6b194cfc1557 8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents: 38074
diff changeset
   238
  _vm_thread = NULL;      // VM thread is gone
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
void VMThread::run() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  assert(this == vm_thread(), "check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
29326
ebaa169c6dc3 8073464: GC workers do not have thread names
david
parents: 29084
diff changeset
   244
  this->initialize_named_thread();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  this->record_stack_base_and_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  // Notify_lock wait checks on active_handles() to rewait in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // case of spurious wakeup, it should wait on the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  // value set prior to the notify
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  this->set_active_handles(JNIHandleBlock::allocate_block());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    MutexLocker ml(Notify_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
    Notify_lock->notify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Notify_lock is destroyed by Threads::create_vm()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  int prio = (VMThreadPriority == -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    ? os::java_to_os_priority[NearMaxPriority]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    : VMThreadPriority;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  // Note that I cannot call os::set_priority because it expects Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  // priorities and I am *explicitly* using OS priorities so that it's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  // possible to set the VM thread priority higher than any Java thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  os::set_native_priority( this, prio );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // Wait for VM_Operations until termination
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  this->loop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  // Note the intention to exit before safepointing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  // 6295565  This has the effect of waiting for any large tty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  // outputs to finish.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  if (xtty != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    xtty->begin_elem("destroy_vm");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    xtty->stamp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    xtty->end_elem();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    assert(should_terminate(), "termination flag must be set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  // 4526887 let VM thread exit at Safepoint
46496
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   280
  _no_op_reason = "Halt";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  SafepointSynchronize::begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  if (VerifyBeforeExit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    HandleMark hm(VMThread::vm_thread());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    // Among other things, this ensures that Eden top is correct.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    Universe::heap()->prepare_for_verify();
9342
456b8d0486b5 7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents: 7397
diff changeset
   287
    // Silent verification so as not to pollute normal output,
456b8d0486b5 7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents: 7397
diff changeset
   288
    // unless we really asked for it.
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 34633
diff changeset
   289
    Universe::verify();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  CompileBroker::set_should_block();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // wait for threads (compiler threads or daemon threads) in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // _thread_in_native state to block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  VM_Exit::wait_for_threads_in_native_to_block();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // signal other threads that VM process is gone
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    // Note: we must have the _no_safepoint_check_flag. Mutex::lock() allows
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    // VM thread to enter any lock at Safepoint as long as its _owner is NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    // If that happens after _terminate_lock->wait() has unset _owner
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    // but before it actually drops the lock and waits, the notification below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    // may get lost and we will have a hang. To avoid this, we need to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    // Mutex::lock_without_safepoint_check().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    MutexLockerEx ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    _terminated = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    _terminate_lock->notify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
38290
6b194cfc1557 8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents: 38074
diff changeset
   311
  // We are now racing with the VM termination being carried out in
6b194cfc1557 8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents: 38074
diff changeset
   312
  // another thread, so we don't "delete this". Numerous threads don't
6b194cfc1557 8154715: Missing destructor and/or TLS clearing calls for terminating threads
dholmes
parents: 38074
diff changeset
   313
  // get deleted when the VM terminates
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
// Notify the VMThread that the last non-daemon JavaThread has terminated,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
// and wait until operation is performed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
void VMThread::wait_for_vm_thread_exit() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  { MutexLocker mu(VMOperationQueue_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    _should_terminate = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    VMOperationQueue_lock->notify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  // Note: VM thread leaves at Safepoint. We are not stopped by Safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // because this thread has been removed from the threads list. But anything
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // that could get blocked by Safepoint should not be used after this point,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // otherwise we will hang, since there is no one can end the safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  // Wait until VM thread is terminated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // Note: it should be OK to use Terminator_lock here. But this is called
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  // at a very delicate time (VM shutdown) and we are operating in non- VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  // thread at Safepoint. It's safer to not share lock with other threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  { MutexLockerEx ml(_terminate_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    while(!VMThread::is_terminated()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
        _terminate_lock->wait(Mutex::_no_safepoint_check_flag);
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
void VMThread::evaluate_operation(VM_Operation* op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    PerfTraceTime vm_op_timer(perf_accumulated_vm_operation_time());
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   347
    HOTSPOT_VMOPS_BEGIN(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   348
                     (char *) op->name(), strlen(op->name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   349
                     op->evaluation_mode());
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   350
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   351
    EventExecuteVMOperation event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   352
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    op->evaluate();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   354
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   355
    if (event.should_commit()) {
37176
663bdc7d0b86 8149023: Event based tracing should cover safepoint begin and end
dsimms
parents: 36384
diff changeset
   356
      const bool is_concurrent = op->evaluate_concurrently();
663bdc7d0b86 8149023: Event based tracing should cover safepoint begin and end
dsimms
parents: 36384
diff changeset
   357
      const bool evaluate_at_safepoint = op->evaluate_at_safepoint();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   358
      event.set_operation(op->type());
37176
663bdc7d0b86 8149023: Event based tracing should cover safepoint begin and end
dsimms
parents: 36384
diff changeset
   359
      event.set_safepoint(evaluate_at_safepoint);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   360
      event.set_blocking(!is_concurrent);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   361
      // Only write caller thread information for non-concurrent vm operations.
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   362
      // For concurrent vm operations, the thread id is set to 0 indicating thread is unknown.
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   363
      // This is because the caller thread could have exited already.
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 35061
diff changeset
   364
      event.set_caller(is_concurrent ? 0 : THREAD_TRACE_ID(op->calling_thread()));
37176
663bdc7d0b86 8149023: Event based tracing should cover safepoint begin and end
dsimms
parents: 36384
diff changeset
   365
      event.set_safepointId(evaluate_at_safepoint ? SafepointSynchronize::safepoint_counter() : 0);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   366
      event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   367
    }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   368
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   369
    HOTSPOT_VMOPS_END(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   370
                     (char *) op->name(), strlen(op->name()),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   371
                     op->evaluation_mode());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  // Last access of info in _cur_vm_operation!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  bool c_heap_allocated = op->is_cheap_allocated();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // Mark as completed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  if (!op->evaluate_concurrently()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    op->calling_thread()->increment_vm_operation_completed_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // It is unsafe to access the _cur_vm_operation after the 'increment_vm_operation_completed_count' call,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // since if it is stack allocated the calling thread might have deallocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  if (c_heap_allocated) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    delete _cur_vm_operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
46496
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   388
bool VMThread::no_op_safepoint_needed(bool check_time) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   389
  if (SafepointALot) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   390
    _no_op_reason = "SafepointALot";
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   391
    return true;
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   392
  }
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   393
  if (!SafepointSynchronize::is_cleanup_needed()) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   394
    return false;
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   395
  }
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   396
  if (check_time) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   397
    long interval = SafepointSynchronize::last_non_safepoint_interval();
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   398
    bool max_time_exceeded = GuaranteedSafepointInterval != 0 &&
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   399
                             (interval > GuaranteedSafepointInterval);
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   400
    if (!max_time_exceeded) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   401
      return false;
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   402
    }
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   403
  }
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   404
  _no_op_reason = "Cleanup";
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   405
  return true;
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   406
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
void VMThread::loop() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  assert(_cur_vm_operation == NULL, "no current one should be executing");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  while(true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    VM_Operation* safepoint_ops = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    // Wait for VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
    // use no_safepoint_check to get lock without attempting to "sneak"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
    { MutexLockerEx mu_queue(VMOperationQueue_lock,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
                             Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
      // Look for new operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      assert(_cur_vm_operation == NULL, "no current one should be executing");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
      _cur_vm_operation = _vm_queue->remove_next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
      // Stall time tracking code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
      if (PrintVMQWaitTime && _cur_vm_operation != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
          !_cur_vm_operation->evaluate_concurrently()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
        long stall = os::javaTimeMillis() - _cur_vm_operation->timestamp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
        if (stall > 0)
33148
68fa8b6c4340 8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 33105
diff changeset
   429
          tty->print_cr("%s stall: %ld",  _cur_vm_operation->name(), stall);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
      while (!should_terminate() && _cur_vm_operation == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
        // wait with a timeout to guarantee safepoints at regular intervals
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
        bool timedout =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
          VMOperationQueue_lock->wait(Mutex::_no_safepoint_check_flag,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
                                      GuaranteedSafepointInterval);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
        // Support for self destruction
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46496
diff changeset
   439
        if ((SelfDestructTimer != 0) && !VMError::is_error_reported() &&
33222
e0a340f4ab6e 8078556: Runtime: implement ranges (optionally constraints) for those flags that have them missing.
gziemski
parents: 33148
diff changeset
   440
            (os::elapsedTime() > (double)SelfDestructTimer * 60.0)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
          tty->print_cr("VM self-destructed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
          exit(-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
46496
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   445
        if (timedout && VMThread::no_op_safepoint_needed(false)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
          MutexUnlockerEx mul(VMOperationQueue_lock,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
                              Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
          // Force a safepoint since we have not had one for at least
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
          // 'GuaranteedSafepointInterval' milliseconds.  This will run all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
          // the clean-up processing that needs to be done regularly at a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
          // safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
          SafepointSynchronize::begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
          #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
            if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
          #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
          SafepointSynchronize::end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
        _cur_vm_operation = _vm_queue->remove_next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
        // If we are at a safepoint we will evaluate all the operations that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
        // follow that also require a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
        if (_cur_vm_operation != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
            _cur_vm_operation->evaluate_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
          safepoint_ops = _vm_queue->drain_at_safepoint_priority();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
      if (should_terminate()) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    } // Release mu_queue_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
    // Execute VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
    { HandleMark hm(VMThread::vm_thread());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      EventMark em("Executing VM operation: %s", vm_operation()->name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
      assert(_cur_vm_operation != NULL, "we should have found an operation to execute");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      // Give the VM thread an extra quantum.  Jobs tend to be bursty and this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
      // helps the VM thread to finish up the job.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
      // FIXME: When this is enabled and there are many threads, this can degrade
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
      // performance significantly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
      if( VMThreadHintNoPreempt )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
        os::hint_no_preempt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
      // If we are at a safepoint we will evaluate all the operations that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
      // follow that also require a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
      if (_cur_vm_operation->evaluate_at_safepoint()) {
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
   489
        log_debug(vmthread)("Evaluating safepoint VM operation: %s", _cur_vm_operation->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
        _vm_queue->set_drain_list(safepoint_ops); // ensure ops can be scanned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
        SafepointSynchronize::begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
        evaluate_operation(_cur_vm_operation);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
        // now process all queued safepoint ops, iteratively draining
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
        // the queue until there are none left
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
        do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
          _cur_vm_operation = safepoint_ops;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
          if (_cur_vm_operation != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
            do {
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
   501
              log_debug(vmthread)("Evaluating coalesced safepoint VM operation: %s", _cur_vm_operation->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
              // evaluate_operation deletes the op object so we have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
              // to grab the next op now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
              VM_Operation* next = _cur_vm_operation->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
              _vm_queue->set_drain_list(next);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
              evaluate_operation(_cur_vm_operation);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
              _cur_vm_operation = next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
              if (PrintSafepointStatistics) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
                SafepointSynchronize::inc_vmop_coalesced_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
              }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
            } while (_cur_vm_operation != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
          // There is a chance that a thread enqueued a safepoint op
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
          // since we released the op-queue lock and initiated the safepoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
          // So we drain the queue again if there is anything there, as an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
          // optimization to try and reduce the number of safepoints.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
          // As the safepoint synchronizes us with JavaThreads we will see
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
          // any enqueue made by a JavaThread, but the peek will not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
          // necessarily detect a concurrent enqueue by a GC thread, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
          // that simply means the op will wait for the next major cycle of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
          // VMThread - just as it would if the GC thread lost the race for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
          // the lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
          if (_vm_queue->peek_at_safepoint_priority()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
            // must hold lock while draining queue
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
            MutexLockerEx mu_queue(VMOperationQueue_lock,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
                                     Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
            safepoint_ops = _vm_queue->drain_at_safepoint_priority();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
          } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
            safepoint_ops = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
        } while(safepoint_ops != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
        _vm_queue->set_drain_list(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
        // Complete safepoint synchronization
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
        SafepointSynchronize::end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
      } else {  // not a safepoint operation
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
   539
        log_debug(vmthread)("Evaluating non-safepoint VM operation: %s", _cur_vm_operation->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
        if (TraceLongCompiles) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
          elapsedTimer t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
          t.start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
          evaluate_operation(_cur_vm_operation);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
          t.stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
          double secs = t.seconds();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
          if (secs * 1e3 > LongCompileThreshold) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
            // XXX - _cur_vm_operation should not be accessed after
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
            // the completed count has been incremented; the waiting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
            // thread may have already freed this memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
            tty->print_cr("vm %s: %3.7f secs]", _cur_vm_operation->name(), secs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
          evaluate_operation(_cur_vm_operation);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
        _cur_vm_operation = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
    //  Notify (potential) waiting Java thread(s) - lock without safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    //  check so that sneaking is not possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    { MutexLockerEx mu(VMOperationRequest_lock,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
                       Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
      VMOperationRequest_lock->notify_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    // We want to make sure that we get to a safepoint regularly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    //
46496
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   571
    if (VMThread::no_op_safepoint_needed(true)) {
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   572
      HandleMark hm(VMThread::vm_thread());
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   573
      SafepointSynchronize::begin();
76ed99d51a67 8152955: Many safepoints of "no vm operation" kind
rehn
parents: 40667
diff changeset
   574
      SafepointSynchronize::end();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
void VMThread::execute(VM_Operation* op) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  Thread* t = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  if (!t->is_VM_thread()) {
2995
d8283445992a 6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents: 1
diff changeset
   583
    SkipGCALot sgcalot(t);    // avoid re-entrant attempts to gc-a-lot
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    // JavaThread or WatcherThread
15235
0a73bc0920e5 8004903: VMThread::execute() calls Thread::check_for_valid_safepoint_state() on concurrent VM ops
dcubed
parents: 14583
diff changeset
   585
    bool concurrent = op->evaluate_concurrently();
0a73bc0920e5 8004903: VMThread::execute() calls Thread::check_for_valid_safepoint_state() on concurrent VM ops
dcubed
parents: 14583
diff changeset
   586
    // only blocking VM operations need to verify the caller's safepoint state:
0a73bc0920e5 8004903: VMThread::execute() calls Thread::check_for_valid_safepoint_state() on concurrent VM ops
dcubed
parents: 14583
diff changeset
   587
    if (!concurrent) {
0a73bc0920e5 8004903: VMThread::execute() calls Thread::check_for_valid_safepoint_state() on concurrent VM ops
dcubed
parents: 14583
diff changeset
   588
      t->check_for_valid_safepoint_state(true);
0a73bc0920e5 8004903: VMThread::execute() calls Thread::check_for_valid_safepoint_state() on concurrent VM ops
dcubed
parents: 14583
diff changeset
   589
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    // New request from Java thread, evaluate prologue
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    if (!op->doit_prologue()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
      return;   // op was cancelled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
    // Setup VM_operations for execution
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
    op->set_calling_thread(t, Thread::get_priority(t));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    // It does not make sense to execute the epilogue, if the VM operation object is getting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
    // deallocated by the VM thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
    bool execute_epilog = !op->is_cheap_allocated();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    assert(!concurrent || op->is_cheap_allocated(), "concurrent => cheap_allocated");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    // Get ticket number for non-concurrent VM operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    int ticket = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
    if (!concurrent) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
      ticket = t->vm_operation_ticket();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
    // Add VM operation to list of waiting threads. We are guaranteed not to block while holding the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
    // VMOperationQueue_lock, so we can block without a safepoint check. This allows vm operation requests
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    // to be queued up during a safepoint synchronization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
      VMOperationQueue_lock->lock_without_safepoint_check();
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
   615
      log_debug(vmthread)("Adding VM operation: %s", op->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
      bool ok = _vm_queue->add(op);
46732
05423d4b10d2 8185273: Test8004741.java crashes with SIGSEGV in JDK10-hs nightly
dcubed
parents: 46589
diff changeset
   617
      op->set_timestamp(os::javaTimeMillis());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
      VMOperationQueue_lock->notify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
      VMOperationQueue_lock->unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
      // VM_Operation got skipped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
      if (!ok) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
        assert(concurrent, "can only skip concurrent tasks");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
        if (op->is_cheap_allocated()) delete op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
        return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    if (!concurrent) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      // Wait for completion of request (non-concurrent)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
      // Note: only a JavaThread triggers the safepoint check when locking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
      MutexLocker mu(VMOperationRequest_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
      while(t->vm_operation_completed_count() < ticket) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
        VMOperationRequest_lock->wait(!t->is_Java_thread());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
    if (execute_epilog) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
      op->doit_epilogue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    // invoked by VM thread; usually nested VM operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
    assert(t->is_VM_thread(), "must be a VM thread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
    VM_Operation* prev_vm_operation = vm_operation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    if (prev_vm_operation != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
      // Check the VM operation allows nested VM operation. This normally not the case, e.g., the compiler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
      // does not allow nested scavenges or compiles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
      if (!prev_vm_operation->allow_nested_vm_operations()) {
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 30764
diff changeset
   648
        fatal("Nested VM operation %s requested by operation %s",
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 30764
diff changeset
   649
              op->name(), vm_operation()->name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
      op->set_calling_thread(prev_vm_operation->calling_thread(), prev_vm_operation->priority());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    EventMark em("Executing %s VM operation: %s", prev_vm_operation ? "nested" : "", op->name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
    // Release all internal handles after operation is evaluated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
    HandleMark hm(t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    _cur_vm_operation = op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    if (op->evaluate_at_safepoint() && !SafepointSynchronize::is_at_safepoint()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      SafepointSynchronize::begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
      op->evaluate();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
      SafepointSynchronize::end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
      op->evaluate();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    // Free memory if needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    if (op->is_cheap_allocated()) delete op;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    _cur_vm_operation = prev_vm_operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
38074
8475fdc6dcc3 8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents: 37176
diff changeset
   676
void VMThread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
8475fdc6dcc3 8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents: 37176
diff changeset
   677
  Thread::oops_do(f, cf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  _vm_queue->oops_do(f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
//------------------------------------------------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
void VMOperationQueue::verify_queue(int prio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // Check that list is correctly linked
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  int length = _queue_length[prio];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  VM_Operation *cur = _queue[prio];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  // Check forward links
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  for(i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    cur = cur->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
    assert(cur != _queue[prio], "list to short (forward)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  assert(cur->next() == _queue[prio], "list to long (forward)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  // Check backwards links
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  cur = _queue[prio];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  for(i = 0; i < length; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    cur = cur->prev();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    assert(cur != _queue[prio], "list to short (backwards)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  assert(cur->prev() == _queue[prio], "list to long (backwards)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
void VMThread::verify() {
38074
8475fdc6dcc3 8154580: Save mirror in interpreter frame to enable cleanups of CLDClosure
coleenp
parents: 37176
diff changeset
   709
  oops_do(&VerifyOopClosure::verify_oop, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
}