src/hotspot/share/gc/shared/collectedHeap.cpp
author stefank
Thu, 08 Mar 2018 19:10:25 +0100
changeset 49361 1956d0ec092a
parent 49045 9b556b613a07
child 49389 9ef2eee8ca7c
permissions -rw-r--r--
8199319: Remove handles.inline.hpp include from reflectionUtils.hpp Reviewed-by: hseigel, dholmes
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
48961
120b61d50f85 8195103: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents: 48168
diff changeset
     2
 * Copyright (c) 2001, 2018, 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: 5544
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5544
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: 5544
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: 6759
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    26
#include "classfile/systemDictionary.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    27
#include "gc/shared/allocTracer.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    28
#include "gc/shared/barrierSet.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    29
#include "gc/shared/collectedHeap.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    30
#include "gc/shared/collectedHeap.inline.hpp"
49045
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
    31
#include "gc/shared/gcLocker.inline.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    32
#include "gc/shared/gcHeapSummary.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    33
#include "gc/shared/gcTrace.hpp"
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    34
#include "gc/shared/gcTraceTime.inline.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    35
#include "gc/shared/gcWhen.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    36
#include "gc/shared/vmGCOperations.hpp"
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    37
#include "logging/log.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    38
#include "memory/metaspace.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 37242
diff changeset
    39
#include "memory/resourceArea.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30152
diff changeset
    40
#include "oops/instanceMirrorKlass.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    41
#include "oops/oop.inline.hpp"
49361
1956d0ec092a 8199319: Remove handles.inline.hpp include from reflectionUtils.hpp
stefank
parents: 49045
diff changeset
    42
#include "runtime/handles.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    43
#include "runtime/init.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 13738
diff changeset
    44
#include "runtime/thread.inline.hpp"
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
    45
#include "runtime/threadSMR.hpp"
49045
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
    46
#include "runtime/vmThread.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    47
#include "services/heapDumper.hpp"
46625
edefffab74e2 8183552: Move align functions to align.hpp
stefank
parents: 46619
diff changeset
    48
#include "utilities/align.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
49045
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
    50
class ClassLoaderData;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
int CollectedHeap::_fire_out_of_memory_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    56
size_t CollectedHeap::_filler_array_max_size = 0;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
    57
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    58
template <>
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    59
void EventLogBase<GCMessage>::print(outputStream* st, GCMessage& m) {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    60
  st->print_cr("GC heap %s", m.is_before ? "before" : "after");
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    61
  st->print_raw(m);
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    62
}
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    63
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    64
void GCHeapLog::log_heap(CollectedHeap* heap, bool before) {
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    65
  if (!should_log()) {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    66
    return;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    67
  }
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    68
11788
bef6166c683c 7145537: minor tweaks to LogEvents
never
parents: 11636
diff changeset
    69
  double timestamp = fetch_timestamp();
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    70
  MutexLockerEx ml(&_mutex, Mutex::_no_safepoint_check_flag);
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    71
  int index = compute_log_index();
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    72
  _records[index].thread = NULL; // Its the GC thread so it's not that interesting.
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    73
  _records[index].timestamp = timestamp;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    74
  _records[index].data.is_before = before;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    75
  stringStream st(_records[index].data.buffer(), _records[index].data.size());
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    76
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    77
  st.print_cr("{Heap %s GC invocations=%u (full %u):",
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    78
                 before ? "before" : "after",
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    79
                 heap->total_collections(),
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    80
                 heap->total_full_collections());
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    81
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    82
  heap->print_on(&st);
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
    83
  st.print_cr("}");
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    84
}
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
    85
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    86
VirtualSpaceSummary CollectedHeap::create_heap_space_summary() {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    87
  size_t capacity_in_words = capacity() / HeapWordSize;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    88
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    89
  return VirtualSpaceSummary(
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    90
    reserved_region().start(), reserved_region().start() + capacity_in_words, reserved_region().end());
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    91
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    92
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    93
GCHeapSummary CollectedHeap::create_heap_summary() {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    94
  VirtualSpaceSummary heap_space = create_heap_space_summary();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    95
  return GCHeapSummary(heap_space, used());
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    96
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    97
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    98
MetaspaceSummary CollectedHeap::create_metaspace_summary() {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
    99
  const MetaspaceSizes meta_space(
23853
3e1633ff6996 8035667: EventMetaspaceSummary doesn't report committed Metaspace memory
ehelin
parents: 23470
diff changeset
   100
      MetaspaceAux::committed_bytes(),
23854
50f7f89b34e0 8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents: 23853
diff changeset
   101
      MetaspaceAux::used_bytes(),
19988
2b100c528806 8023476: Metaspace capacity > reserved
ehelin
parents: 19339
diff changeset
   102
      MetaspaceAux::reserved_bytes());
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   103
  const MetaspaceSizes data_space(
23853
3e1633ff6996 8035667: EventMetaspaceSummary doesn't report committed Metaspace memory
ehelin
parents: 23470
diff changeset
   104
      MetaspaceAux::committed_bytes(Metaspace::NonClassType),
23854
50f7f89b34e0 8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents: 23853
diff changeset
   105
      MetaspaceAux::used_bytes(Metaspace::NonClassType),
19988
2b100c528806 8023476: Metaspace capacity > reserved
ehelin
parents: 19339
diff changeset
   106
      MetaspaceAux::reserved_bytes(Metaspace::NonClassType));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   107
  const MetaspaceSizes class_space(
23853
3e1633ff6996 8035667: EventMetaspaceSummary doesn't report committed Metaspace memory
ehelin
parents: 23470
diff changeset
   108
      MetaspaceAux::committed_bytes(Metaspace::ClassType),
23854
50f7f89b34e0 8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents: 23853
diff changeset
   109
      MetaspaceAux::used_bytes(Metaspace::ClassType),
19988
2b100c528806 8023476: Metaspace capacity > reserved
ehelin
parents: 19339
diff changeset
   110
      MetaspaceAux::reserved_bytes(Metaspace::ClassType));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   111
23470
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   112
  const MetaspaceChunkFreeListSummary& ms_chunk_free_list_summary =
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   113
    MetaspaceAux::chunk_free_list_summary(Metaspace::NonClassType);
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   114
  const MetaspaceChunkFreeListSummary& class_chunk_free_list_summary =
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   115
    MetaspaceAux::chunk_free_list_summary(Metaspace::ClassType);
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   116
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   117
  return MetaspaceSummary(MetaspaceGC::capacity_until_GC(), meta_space, data_space, class_space,
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   118
                          ms_chunk_free_list_summary, class_chunk_free_list_summary);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   119
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   120
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   121
void CollectedHeap::print_heap_before_gc() {
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   122
  Universe::print_heap_before_gc();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   123
  if (_gc_heap_log != NULL) {
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   124
    _gc_heap_log->log_heap_before(this);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   125
  }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   126
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   127
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   128
void CollectedHeap::print_heap_after_gc() {
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   129
  Universe::print_heap_after_gc();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   130
  if (_gc_heap_log != NULL) {
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   131
    _gc_heap_log->log_heap_after(this);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   132
  }
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   133
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   134
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   135
void CollectedHeap::print_on_error(outputStream* st) const {
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   136
  st->print_cr("Heap:");
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   137
  print_extended_on(st);
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   138
  st->cr();
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   139
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   140
  _barrier_set->print_on(st);
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   141
}
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   142
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 26829
diff changeset
   143
void CollectedHeap::trace_heap(GCWhen::Type when, const GCTracer* gc_tracer) {
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   144
  const GCHeapSummary& heap_summary = create_heap_summary();
23470
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   145
  gc_tracer->report_gc_heap_summary(when, heap_summary);
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   146
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   147
  const MetaspaceSummary& metaspace_summary = create_metaspace_summary();
23470
ff2a7ea4225d 8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents: 23464
diff changeset
   148
  gc_tracer->report_metaspace_summary(when, metaspace_summary);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   149
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   150
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 26829
diff changeset
   151
void CollectedHeap::trace_heap_before_gc(const GCTracer* gc_tracer) {
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   152
  trace_heap(GCWhen::BeforeGC, gc_tracer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   153
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   154
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 26829
diff changeset
   155
void CollectedHeap::trace_heap_after_gc(const GCTracer* gc_tracer) {
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   156
  trace_heap(GCWhen::AfterGC, gc_tracer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   157
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   158
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   159
// WhiteBox API support for concurrent collectors.  These are the
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   160
// default implementations, for collectors which don't support this
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   161
// feature.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   162
bool CollectedHeap::supports_concurrent_phase_control() const {
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   163
  return false;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   164
}
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   165
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   166
const char* const* CollectedHeap::concurrent_phases() const {
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   167
  static const char* const result[] = { NULL };
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   168
  return result;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   169
}
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   170
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   171
bool CollectedHeap::request_concurrent_phase(const char* phase) {
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   172
  return false;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   173
}
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   174
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
// Memory state functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5702
diff changeset
   177
32623
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   178
CollectedHeap::CollectedHeap() :
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   179
  _barrier_set(NULL),
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   180
  _is_gc_active(false),
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   181
  _total_collections(0),
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   182
  _total_full_collections(0),
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   183
  _gc_cause(GCCause::_no_gc),
48961
120b61d50f85 8195103: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents: 48168
diff changeset
   184
  _gc_lastcause(GCCause::_no_gc)
32623
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   185
{
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   186
  const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT));
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   187
  const size_t elements_per_word = HeapWordSize / sizeof(jint);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   188
  _filler_array_max_size = align_object_size(filler_array_hdr_size() +
12229
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11788
diff changeset
   189
                                             max_len / elements_per_word);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   190
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  NOT_PRODUCT(_promotion_failure_alot_count = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    // create the gc cause jvmstat counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
    _perf_gc_cause = PerfDataManager::create_string_variable(SUN_GC, "cause",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
                             80, GCCause::to_string(_gc_cause), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    _perf_gc_lastcause =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
                PerfDataManager::create_string_variable(SUN_GC, "lastCause",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
                             80, GCCause::to_string(_gc_lastcause), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
32623
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31603
diff changeset
   205
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   206
  // Create the ring log
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   207
  if (LogEvents) {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   208
    _gc_heap_log = new GCHeapLog();
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   209
  } else {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   210
    _gc_heap_log = NULL;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11414
diff changeset
   211
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   214
// This interface assumes that it's being called by the
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   215
// vm thread. It collects the heap assuming that the
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   216
// heap lock is already held and that we are executing in
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   217
// the context of the vm thread.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   218
void CollectedHeap::collect_as_vm_thread(GCCause::Cause cause) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   219
  assert(Thread::current()->is_VM_thread(), "Precondition#1");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   220
  assert(Heap_lock->is_locked(), "Precondition#2");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   221
  GCCauseSetter gcs(this, cause);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   222
  switch (cause) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   223
    case GCCause::_heap_inspection:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   224
    case GCCause::_heap_dump:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   225
    case GCCause::_metadata_GC_threshold : {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   226
      HandleMark hm;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   227
      do_full_collection(false);        // don't clear all soft refs
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   228
      break;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   229
    }
37149
f025738bbada 8152113: Remove _last_ditch_collection GC-cause and avoid expanding heap on Metaspace OOM
sjohanss
parents: 36363
diff changeset
   230
    case GCCause::_metadata_GC_clear_soft_refs: {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   231
      HandleMark hm;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   232
      do_full_collection(true);         // do clear all soft refs
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   233
      break;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   234
    }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   235
    default:
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   236
      ShouldNotReachHere(); // Unexpected use of this function
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   237
  }
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   238
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12236
diff changeset
   239
49045
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   240
MetaWord* CollectedHeap::satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   241
                                                            size_t word_size,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   242
                                                            Metaspace::MetadataType mdtype) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   243
  uint loop_count = 0;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   244
  uint gc_count = 0;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   245
  uint full_gc_count = 0;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   246
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   247
  assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock");
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   248
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   249
  do {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   250
    MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   251
    if (result != NULL) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   252
      return result;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   253
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   254
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   255
    if (GCLocker::is_active_and_needs_gc()) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   256
      // If the GCLocker is active, just expand and allocate.
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   257
      // If that does not succeed, wait if this thread is not
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   258
      // in a critical section itself.
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   259
      result = loader_data->metaspace_non_null()->expand_and_allocate(word_size, mdtype);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   260
      if (result != NULL) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   261
        return result;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   262
      }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   263
      JavaThread* jthr = JavaThread::current();
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   264
      if (!jthr->in_critical()) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   265
        // Wait for JNI critical section to be exited
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   266
        GCLocker::stall_until_clear();
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   267
        // The GC invoked by the last thread leaving the critical
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   268
        // section will be a young collection and a full collection
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   269
        // is (currently) needed for unloading classes so continue
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   270
        // to the next iteration to get a full GC.
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   271
        continue;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   272
      } else {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   273
        if (CheckJNICalls) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   274
          fatal("Possible deadlock due to allocating while"
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   275
                " in jni critical section");
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   276
        }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   277
        return NULL;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   278
      }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   279
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   280
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   281
    {  // Need lock to get self consistent gc_count's
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   282
      MutexLocker ml(Heap_lock);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   283
      gc_count      = Universe::heap()->total_collections();
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   284
      full_gc_count = Universe::heap()->total_full_collections();
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   285
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   286
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   287
    // Generate a VM operation
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   288
    VM_CollectForMetadataAllocation op(loader_data,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   289
                                       word_size,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   290
                                       mdtype,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   291
                                       gc_count,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   292
                                       full_gc_count,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   293
                                       GCCause::_metadata_GC_threshold);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   294
    VMThread::execute(&op);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   295
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   296
    // If GC was locked out, try again. Check before checking success because the
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   297
    // prologue could have succeeded and the GC still have been locked out.
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   298
    if (op.gc_locked()) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   299
      continue;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   300
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   301
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   302
    if (op.prologue_succeeded()) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   303
      return op.result();
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   304
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   305
    loop_count++;
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   306
    if ((QueuedAllocationWarningCount > 0) &&
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   307
        (loop_count % QueuedAllocationWarningCount == 0)) {
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   308
      log_warning(gc, ergo)("satisfy_failed_metadata_allocation() retries %d times,"
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   309
                            " size=" SIZE_FORMAT, loop_count, word_size);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   310
    }
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   311
  } while (true);  // Until a GC is done
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   312
}
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 48961
diff changeset
   313
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29081
diff changeset
   314
void CollectedHeap::set_barrier_set(BarrierSet* barrier_set) {
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29081
diff changeset
   315
  _barrier_set = barrier_set;
47998
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47799
diff changeset
   316
  BarrierSet::set_bs(barrier_set);
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29081
diff changeset
   317
}
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29081
diff changeset
   318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
void CollectedHeap::check_for_bad_heap_word_value(HeapWord* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    for (size_t slot = 0; slot < size; slot += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
      assert((*(intptr_t*) (addr + slot)) != ((intptr_t) badHeapWordVal),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
             "Found badHeapWordValue in post-allocation check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
8296
b1c2163e4e59 6912621: iCMS: Error: assert(_markBitMap.isMarked(addr + 1),"Missing Printezis bit?")
ysr
parents: 7397
diff changeset
   329
void CollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr, size_t size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    for (size_t slot = 0; slot < size; slot += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
      assert((*(intptr_t*) (addr + slot)) == ((intptr_t) badHeapWordVal),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
             "Found non badHeapWordValue in pre-allocation check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
#endif // PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
void CollectedHeap::check_for_valid_allocation_state() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  Thread *thread = Thread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // How to choose between a pending exception and a potential
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // OutOfMemoryError?  Don't allow pending exceptions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // This is a VM policy failure, so how do we exhaustively test it?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  assert(!thread->has_pending_exception(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
         "shouldn't be allocating with pending exception");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  if (StrictSafepointChecks) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    assert(thread->allow_allocation(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
           "Allocation done by thread for which allocation is blocked "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
           "by No_Allocation_Verifier!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    // Allocation of an oop can always invoke a safepoint,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    // hence, the true argument
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
    thread->check_for_valid_safepoint_state(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43455
diff changeset
   358
HeapWord* CollectedHeap::allocate_from_tlab_slow(Klass* klass, Thread* thread, size_t size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  // Retain tlab and allocate object in shared space if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  // the amount free in the tlab is too large to discard.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  if (thread->tlab().free() > thread->tlab().refill_waste_limit()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    thread->tlab().record_slow_allocation(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // Discard tlab and allocate a new one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // To minimize fragmentation, the last TLAB may be smaller than the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  size_t new_tlab_size = thread->tlab().compute_size(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  thread->tlab().clear_before_allocation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  if (new_tlab_size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // Allocate a new TLAB...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  HeapWord* obj = Universe::heap()->allocate_new_tlab(new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  if (obj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   382
47779
24022215d092 8189440: Event tracing macros for allocation and weak oops processing
egahlin
parents: 47658
diff changeset
   383
  AllocTracer::send_allocation_in_new_tlab(klass, obj, new_tlab_size * HeapWordSize, size * HeapWordSize, thread);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   384
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  if (ZeroTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    // ..and clear it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    Copy::zero_to_words(obj, new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  } else {
10501
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   389
    // ...and zap just allocated object.
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   390
#ifdef ASSERT
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   391
    // Skip mangling the space corresponding to the object header to
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   392
    // ensure that the returned space is not considered parsable by
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   393
    // any concurrent GC thread.
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   394
    size_t hdr_size = oopDesc::header_size();
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   395
    Copy::fill_to_words(obj + hdr_size, new_tlab_size - hdr_size, badHeapWordVal);
5bce84af0883 7059037: Use BIS for zeroing on T4
kvn
parents: 8921
diff changeset
   396
#endif // ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  thread->tlab().fill(obj, obj + size, new_tlab_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   402
size_t CollectedHeap::max_tlab_size() const {
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   403
  // TLABs can't be bigger than we can fill with a int[Integer.MAX_VALUE].
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   404
  // This restriction could be removed by enabling filling with multiple arrays.
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   405
  // If we compute that the reasonable way as
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   406
  //    header_size + ((sizeof(jint) * max_jint) / HeapWordSize)
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   407
  // we'll overflow on the multiply, so we do the divide first.
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   408
  // We actually lose a little by dividing first,
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   409
  // but that just makes the TLAB  somewhat smaller than the biggest array,
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   410
  // which is fine, since we'll be able to fill that.
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   411
  size_t max_int_size = typeArrayOopDesc::header_size(T_INT) +
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   412
              sizeof(jint) *
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   413
              ((juint) max_jint / (size_t) HeapWordSize);
46619
a3919f5e8d2b 8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents: 46618
diff changeset
   414
  return align_down(max_int_size, MinObjAlignment);
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   415
}
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 21561
diff changeset
   416
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   417
size_t CollectedHeap::filler_array_hdr_size() {
46618
d503911aa948 8178489: Make align functions more type safe and consistent
stefank
parents: 46384
diff changeset
   418
  return align_object_offset(arrayOopDesc::header_size(T_INT)); // align to Long
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   419
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   420
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   421
size_t CollectedHeap::filler_array_min_size() {
5694
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 5544
diff changeset
   422
  return align_object_size(filler_array_hdr_size()); // align to MinObjAlignment
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   423
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   424
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   425
#ifdef ASSERT
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   426
void CollectedHeap::fill_args_check(HeapWord* start, size_t words)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   427
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   428
  assert(words >= min_fill_size(), "too small to fill");
46683
33808f7eadd5 8184753: Asserts against MinObjectAlignment should avoid integer division
shade
parents: 46625
diff changeset
   429
  assert(is_object_aligned(words), "unaligned size");
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   430
  assert(Universe::heap()->is_in_reserved(start), "not in heap");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   431
  assert(Universe::heap()->is_in_reserved(start + words - 1), "not in heap");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   432
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   433
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   434
void CollectedHeap::zap_filler_array(HeapWord* start, size_t words, bool zap)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   435
{
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   436
  if (ZapFillerObjects && zap) {
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   437
    Copy::fill_to_words(start + filler_array_hdr_size(),
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   438
                        words - filler_array_hdr_size(), 0XDEAFBABE);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   439
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   440
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   441
#endif // ASSERT
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   442
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   443
void
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   444
CollectedHeap::fill_with_array(HeapWord* start, size_t words, bool zap)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   445
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   446
  assert(words >= filler_array_min_size(), "too small for an array");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   447
  assert(words <= filler_array_max_size(), "too big for a single object");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   448
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   449
  const size_t payload_size = words - filler_array_hdr_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   450
  const size_t len = payload_size * HeapWordSize / sizeof(jint);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32623
diff changeset
   451
  assert((int)len >= 0, "size too large " SIZE_FORMAT " becomes %d", words, (int)len);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   452
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   453
  // Set the length first for concurrent GC.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   454
  ((arrayOop)start)->set_length((int)len);
12236
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 12229
diff changeset
   455
  post_allocation_setup_common(Universe::intArrayKlassObj(), start);
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   456
  DEBUG_ONLY(zap_filler_array(start, words, zap);)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   457
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   458
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   459
void
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   460
CollectedHeap::fill_with_object_impl(HeapWord* start, size_t words, bool zap)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   461
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   462
  assert(words <= filler_array_max_size(), "too big for a single object");
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   463
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   464
  if (words >= filler_array_min_size()) {
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   465
    fill_with_array(start, words, zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   466
  } else if (words > 0) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   467
    assert(words == min_fill_size(), "unaligned size");
12236
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 12229
diff changeset
   468
    post_allocation_setup_common(SystemDictionary::Object_klass(), start);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   469
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   470
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   471
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   472
void CollectedHeap::fill_with_object(HeapWord* start, size_t words, bool zap)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   473
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   474
  DEBUG_ONLY(fill_args_check(start, words);)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   475
  HandleMark hm;  // Free handles before leaving.
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   476
  fill_with_object_impl(start, words, zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   477
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   478
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   479
void CollectedHeap::fill_with_objects(HeapWord* start, size_t words, bool zap)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   480
{
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   481
  DEBUG_ONLY(fill_args_check(start, words);)
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   482
  HandleMark hm;  // Free handles before leaving.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   483
31603
4bd3b4863e10 8129573: CollectedHeap::fill_with_objects() needs to use multiple arrays in 32 bit mode too
tschatzl
parents: 30870
diff changeset
   484
  // Multiple objects may be required depending on the filler array maximum size. Fill
4bd3b4863e10 8129573: CollectedHeap::fill_with_objects() needs to use multiple arrays in 32 bit mode too
tschatzl
parents: 30870
diff changeset
   485
  // the range up to that with objects that are filler_array_max_size sized. The
4bd3b4863e10 8129573: CollectedHeap::fill_with_objects() needs to use multiple arrays in 32 bit mode too
tschatzl
parents: 30870
diff changeset
   486
  // remainder is filled with a single object.
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   487
  const size_t min = min_fill_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   488
  const size_t max = filler_array_max_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   489
  while (words > max) {
31603
4bd3b4863e10 8129573: CollectedHeap::fill_with_objects() needs to use multiple arrays in 32 bit mode too
tschatzl
parents: 30870
diff changeset
   490
    const size_t cur = (words - max) >= min ? max : max - min;
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   491
    fill_with_array(start, cur, zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   492
    start += cur;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   493
    words -= cur;
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   494
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   495
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4571
diff changeset
   496
  fill_with_object_impl(start, words, zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   497
}
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   498
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
HeapWord* CollectedHeap::allocate_new_tlab(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  guarantee(false, "thread-local allocation buffers not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
void CollectedHeap::ensure_parsability(bool retire_tlabs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // The second disjunct in the assertion below makes a concession
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // for the start-up verification done while the VM is being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // created. Callers be careful that you know that mutators
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // aren't going to interfere -- for instance, this is permissible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // if we are still single-threaded and have either not yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // started allocating (nothing much to verify) or we have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  // started allocating but are now a full-fledged JavaThread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  // (and have thus made our TLAB's) available for filling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
         "Should only be called at a safepoint or at start-up"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
         " otherwise concurrent mutator activity may make heap "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
         " unparsable again");
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   518
  const bool use_tlab = UseTLAB;
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   519
  // The main thread starts allocating via a TLAB even before it
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   520
  // has added itself to the threads list at vm boot-up.
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
   521
  JavaThreadIteratorWithHandle jtiwh;
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
   522
  assert(!use_tlab || jtiwh.length() > 0,
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   523
         "Attempt to fill tlabs before main thread has been added"
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   524
         " to threads list is doomed to failure!");
48961
120b61d50f85 8195103: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents: 48168
diff changeset
   525
  BarrierSet *bs = barrier_set();
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
   526
  for (; JavaThread *thread = jtiwh.next(); ) {
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   527
     if (use_tlab) thread->tlab().make_parsable(retire_tlabs);
48961
120b61d50f85 8195103: Refactor out card table from CardTableModRefBS to flatten the BarrierSet hierarchy
eosterlund
parents: 48168
diff changeset
   528
     bs->make_parsable(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
void CollectedHeap::accumulate_statistics_all_tlabs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
         "should only accumulate statistics on tlabs at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    ThreadLocalAllocBuffer::accumulate_statistics_before_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
void CollectedHeap::resize_all_tlabs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  if (UseTLAB) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    assert(SafepointSynchronize::is_at_safepoint() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
         !is_init_completed(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
         "should only resize tlabs at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    ThreadLocalAllocBuffer::resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
}
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   551
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35529
diff changeset
   552
void CollectedHeap::full_gc_dump(GCTimer* timer, bool before) {
35939
05df7e64ecfc 8149035: Make the full_gc_dump() calls be recorded as part of the GC
brutisso
parents: 35915
diff changeset
   553
  assert(timer != NULL, "timer is null");
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35529
diff changeset
   554
  if ((HeapDumpBeforeFullGC && before) || (HeapDumpAfterFullGC && !before)) {
35939
05df7e64ecfc 8149035: Make the full_gc_dump() calls be recorded as part of the GC
brutisso
parents: 35915
diff changeset
   555
    GCTraceTime(Info, gc) tm(before ? "Heap Dump (before full gc)" : "Heap Dump (after full gc)", timer);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   556
    HeapDumper::dump_heap();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   557
  }
35939
05df7e64ecfc 8149035: Make the full_gc_dump() calls be recorded as part of the GC
brutisso
parents: 35915
diff changeset
   558
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46683
diff changeset
   559
  LogTarget(Trace, gc, classhisto) lt;
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46683
diff changeset
   560
  if (lt.is_enabled()) {
35939
05df7e64ecfc 8149035: Make the full_gc_dump() calls be recorded as part of the GC
brutisso
parents: 35915
diff changeset
   561
    GCTraceTime(Trace, gc, classhisto) tm(before ? "Class Histogram (before full gc)" : "Class Histogram (after full gc)", timer);
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   562
    ResourceMark rm;
46701
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46683
diff changeset
   563
    LogStream ls(lt);
f559541c0daa 8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents: 46683
diff changeset
   564
    VM_GC_HeapInspection inspector(&ls, false /* ! full gc */);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   565
    inspector.doit();
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   566
  }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   567
}
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   568
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   569
void CollectedHeap::pre_full_gc_dump(GCTimer* timer) {
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35529
diff changeset
   570
  full_gc_dump(timer, true);
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   571
}
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33198
diff changeset
   572
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 14583
diff changeset
   573
void CollectedHeap::post_full_gc_dump(GCTimer* timer) {
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35529
diff changeset
   574
  full_gc_dump(timer, false);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 1681
diff changeset
   575
}
10742
a64c942e4e6b 7098528: crash with java -XX:+ExtendedDTraceProbes
never
parents: 10565
diff changeset
   576
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   577
void CollectedHeap::initialize_reserved_region(HeapWord *start, HeapWord *end) {
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   578
  // It is important to do this in a way such that concurrent readers can't
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   579
  // temporarily think something is in the heap.  (Seen this happen in asserts.)
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   580
  _reserved.set_word_size(0);
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   581
  _reserved.set_start(start);
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   582
  _reserved.set_end(end);
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25350
diff changeset
   583
}
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 48105
diff changeset
   584
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 48105
diff changeset
   585
void CollectedHeap::post_initialize() {
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 48105
diff changeset
   586
  initialize_serviceability();
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 48105
diff changeset
   587
}