hotspot/src/share/vm/memory/genCollectedHeap.cpp
author brutisso
Thu, 02 Apr 2015 16:08:41 +0200
changeset 30154 39cd4e2ccf1c
parent 30153 596ed88949ad
child 30155 a3a254791703
permissions -rw-r--r--
8076452: Remove SharedHeap Reviewed-by: stefank, sjohanss, david
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
28939
0d2964a78d0e 8065093: Remove unused variable/output argument
tschatzl
parents: 28217
diff changeset
     2
 * Copyright (c) 2000, 2015, 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: 5433
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5433
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: 5433
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: 6985
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    26
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    28
#include "classfile/vmSymbols.hpp"
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    29
#include "code/codeCache.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    30
#include "code/icBuffer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    31
#include "gc_implementation/shared/collectorCounters.hpp"
25350
6423a57e5451 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 24941
diff changeset
    32
#include "gc_implementation/shared/gcTrace.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
    33
#include "gc_implementation/shared/gcTraceTime.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    34
#include "gc_implementation/shared/vmGCOperations.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    35
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    36
#include "memory/filemap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    37
#include "memory/gcLocker.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    38
#include "memory/genCollectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    39
#include "memory/genOopClosures.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    40
#include "memory/generationSpec.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    41
#include "memory/resourceArea.hpp"
30153
596ed88949ad 8076289: Move the StrongRootsScope out of SharedHeap
brutisso
parents: 30152
diff changeset
    42
#include "memory/strongRootsScope.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    43
#include "memory/space.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    44
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    45
#include "runtime/biasedLocking.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    46
#include "runtime/fprofiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    47
#include "runtime/handles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    48
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    49
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    50
#include "runtime/vmThread.hpp"
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    51
#include "services/management.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    52
#include "services/memoryService.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    53
#include "utilities/vmError.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    54
#include "utilities/workgroup.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
    55
#include "utilities/macros.hpp"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
    56
#if INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    57
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    58
#include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
    59
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
GenCollectedHeap* GenCollectedHeap::_gch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
    64
// The set of potentially parallel tasks in root scanning.
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
    65
enum GCH_strong_roots_tasks {
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    66
  GCH_PS_Universe_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    67
  GCH_PS_JNIHandles_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    68
  GCH_PS_ObjectSynchronizer_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    69
  GCH_PS_FlatProfiler_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    70
  GCH_PS_Management_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    71
  GCH_PS_SystemDictionary_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    72
  GCH_PS_ClassLoaderDataGraph_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    73
  GCH_PS_jvmti_oops_do,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    74
  GCH_PS_CodeCache_oops_do,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  GCH_PS_younger_gens,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // Leave this one last.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  GCH_PS_NumElements
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30153
diff changeset
    81
  CollectedHeap(),
28217
57791914628c 8067499: G1SATBCardTableModRefBS should not inherit from CardTableModRefBSForCTRS
kbarrett
parents: 28212
diff changeset
    82
  _rem_set(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  _gen_policy(policy),
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
    84
  _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  _full_collections_completed(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  assert(policy != NULL, "Sanity check");
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    88
  if (UseConcMarkSweepGC) {
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    89
    _workers = new FlexibleWorkGang("GC Thread", ParallelGCThreads,
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    90
                            /* are_GC_task_threads */true,
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    91
                            /* are_ConcurrentGC_threads */false);
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    92
    _workers->initialize_workers();
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    93
  } else {
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    94
    // Serial GC does not use workers.
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    95
    _workers = NULL;
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
    96
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
jint GenCollectedHeap::initialize() {
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 3908
diff changeset
   100
  CollectedHeap::pre_initialize();
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 3908
diff changeset
   101
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  _n_gens = gen_policy()->number_of_generations();
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   103
  assert(_n_gens == 2, "There is no support for more than two generations");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // While there are no constraints in the GC code that HeapWordSize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  // be any particular value, there are multiple other areas in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // system which believe this to be true (e.g. oop->object_size in some
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  // cases incorrectly returns the size in wordSize units rather than
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  // HeapWordSize).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // Allocate space for the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  char* heap_address;
19546
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   115
  ReservedSpace heap_rs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   117
  size_t heap_alignment = collector_policy()->heap_alignment();
19546
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   118
28939
0d2964a78d0e 8065093: Remove unused variable/output argument
tschatzl
parents: 28217
diff changeset
   119
  heap_address = allocate(heap_alignment, &heap_rs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  if (!heap_rs.is_reserved()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    vm_shutdown_during_initialization(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
      "Could not reserve enough space for object heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    return JNI_ENOMEM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 26183
diff changeset
   127
  initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
27687
3a6367d7110b 8064721: The card tables only ever need two covering regions
ehelin
parents: 27252
diff changeset
   129
  _rem_set = collector_policy()->create_rem_set(reserved_region());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  set_barrier_set(rem_set()->bs());
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 3908
diff changeset
   131
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  _gch = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   134
  ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   135
  _young_gen = gen_policy()->young_gen_spec()->init(young_rs, 0, rem_set());
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   136
  heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   137
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   138
  ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   139
  _old_gen = gen_policy()->old_gen_spec()->init(old_rs, 1, rem_set());
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 6759
diff changeset
   140
  clear_incremental_collection_failed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   142
#if INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // If we are running CMS, create the collector responsible
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // for collecting the CMS generations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  if (collector_policy()->is_concurrent_mark_sweep_policy()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    bool success = create_cms_collector();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    if (!success) return JNI_ENOMEM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   149
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
char* GenCollectedHeap::allocate(size_t alignment,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
                                 ReservedSpace* heap_rs){
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // Now figure out the total size.
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   157
  const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
19546
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   158
  assert(alignment % pageSize == 0, "Must be");
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   159
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   160
  GenerationSpec* young_spec = gen_policy()->young_gen_spec();
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   161
  GenerationSpec* old_spec = gen_policy()->old_gen_spec();
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   162
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   163
  // Check for overflow.
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   164
  size_t total_reserved = young_spec->max_size() + old_spec->max_size();
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   165
  if (total_reserved < young_spec->max_size()) {
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   166
    vm_exit_during_initialization("The size of the object heap + VM data exceeds "
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 29693
diff changeset
   167
                                  "the maximum representable size");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  }
19546
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   169
  assert(total_reserved % alignment == 0,
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   170
         err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment="
f6b7c9e96ea3 8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents: 19322
diff changeset
   171
                 SIZE_FORMAT, total_reserved, alignment));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   173
  *heap_rs = Universe::reserve_heap(total_reserved, alignment);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   174
  return heap_rs->base();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
void GenCollectedHeap::post_initialize() {
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   178
  CollectedHeap::post_initialize();
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   179
  ref_processing_init();
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23854
diff changeset
   180
  GenCollectorPolicy *policy = (GenCollectorPolicy *)collector_policy();
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23854
diff changeset
   181
  guarantee(policy->is_generation_policy(), "Illegal policy type");
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   182
  assert((_young_gen->kind() == Generation::DefNew) ||
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   183
         (_young_gen->kind() == Generation::ParNew),
27903
14c6e2f23fa0 8065992: Change CMSCollector::_young_gen to be a ParNewGeneration*
brutisso
parents: 27898
diff changeset
   184
    "Wrong youngest generation type");
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   185
  DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   187
  assert(_old_gen->kind() == Generation::ConcurrentMarkSweep ||
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   188
         _old_gen->kind() == Generation::MarkSweepCompact,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    "Wrong generation kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  policy->initialize_size_policy(def_new_gen->eden()->capacity(),
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
   192
                                 _old_gen->capacity(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
                                 def_new_gen->from()->capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  policy->initialize_gc_policy_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
void GenCollectedHeap::ref_processing_init() {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   198
  _young_gen->ref_processor_init();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   199
  _old_gen->ref_processor_init();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
size_t GenCollectedHeap::capacity() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   203
  return _young_gen->capacity() + _old_gen->capacity();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
size_t GenCollectedHeap::used() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   207
  return _young_gen->used() + _old_gen->used();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   210
// Save the "used_region" for generations level and lower.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   211
void GenCollectedHeap::save_used_regions(int level) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   212
  assert(level >= 0, "Illegal level parameter");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  assert(level < _n_gens, "Illegal level parameter");
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   214
  if (level == 1) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   215
    _old_gen->save_used_region();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   217
  _young_gen->save_used_region();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
size_t GenCollectedHeap::max_capacity() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   221
  return _young_gen->max_capacity() + _old_gen->max_capacity();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
// Update the _full_collections_completed counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
// at the end of a stop-world full GC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
unsigned int GenCollectedHeap::update_full_collections_completed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  assert(_full_collections_completed <= _total_full_collections,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
         "Can't complete more collections than were started");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  _full_collections_completed = _total_full_collections;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  ml.notify_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  return _full_collections_completed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
// Update the _full_collections_completed counter, as appropriate,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
// at the end of a concurrent GC cycle. Note the conditional update
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
// below to allow this method to be called by a concurrent collector
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
// without synchronizing in any manner with the VM thread (which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
// may already have initiated a STW full collection "concurrently").
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
unsigned int GenCollectedHeap::update_full_collections_completed(unsigned int count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  MonitorLockerEx ml(FullGCCount_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  assert((_full_collections_completed <= _total_full_collections) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
         (count <= _total_full_collections),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
         "Can't complete more collections than were started");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  if (count > _full_collections_completed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    _full_collections_completed = count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    ml.notify_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  return _full_collections_completed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
// Override of memory state checking method in CollectedHeap:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
// Some collectors (CMS for example) can't have badHeapWordVal written
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
// in the first two words of an object. (For instance , in the case of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
// CMS these words hold state used to synchronize between certain
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
// (concurrent) GC steps and direct allocating mutators.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
// The skip_header_HeapWords() method below, allows us to skip
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
// over the requisite number of HeapWord's. Note that (for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
// generational collectors) this means that those many words are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
// skipped in each object, irrespective of the generation in which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
// that object lives. The resultant loss of precision seems to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
// harmless and the pain of avoiding that imprecision appears somewhat
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// higher than we are prepared to pay for such rudimentary debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
// support.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
void GenCollectedHeap::check_for_non_bad_heap_word_value(HeapWord* addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
                                                         size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  if (CheckMemoryInitialization && ZapUnusedHeapArea) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    // We are asked to check a size in HeapWords,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    // but the memory is mangled in juint words.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    juint* start = (juint*) (addr + skip_header_HeapWords());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    juint* end   = (juint*) (addr + size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    for (juint* slot = start; slot < end; slot += 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
      assert(*slot == badHeapWordVal,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
             "Found non badHeapWordValue in pre-allocation check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
HeapWord* GenCollectedHeap::attempt_allocation(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
                                               bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
                                               bool first_only) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   285
  HeapWord* res = NULL;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   286
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   287
  if (_young_gen->should_allocate(size, is_tlab)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   288
    res = _young_gen->allocate(size, is_tlab);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   289
    if (res != NULL || first_only) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   290
      return res;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   293
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   294
  if (_old_gen->should_allocate(size, is_tlab)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   295
    res = _old_gen->allocate(size, is_tlab);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   296
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   297
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   298
  return res;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
HeapWord* GenCollectedHeap::mem_allocate(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
                                         bool* gc_overhead_limit_was_exceeded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  return collector_policy()->mem_allocate_work(size,
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   304
                                               false /* is_tlab */,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
                                               gc_overhead_limit_was_exceeded);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
bool GenCollectedHeap::must_clear_all_soft_refs() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  return _gc_cause == GCCause::_last_ditch_collection;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
bool GenCollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
5433
c182d4c3039e 6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents: 5343
diff changeset
   313
  return UseConcMarkSweepGC &&
c182d4c3039e 6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents: 5343
diff changeset
   314
         ((cause == GCCause::_gc_locker && GCLockerInvokesConcurrent) ||
c182d4c3039e 6919638: CMS: ExplicitGCInvokesConcurrent misinteracts with gc locker
ysr
parents: 5343
diff changeset
   315
          (cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   318
void GenCollectedHeap::collect_generation(Generation* gen, bool full, size_t size,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   319
                                          bool is_tlab, bool run_verification, bool clear_soft_refs,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   320
                                          bool restore_marks_for_biased_locking) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   321
  // Timer for individual generations. Last argument is false: no CR
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   322
  // FIXME: We should try to start the timing earlier to cover more of the GC pause
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   323
  // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   324
  // so we can assume here that the next GC id is what we want.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   325
  GCTraceTime t1(gen->short_name(), PrintGCDetails, false, NULL, GCId::peek());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   326
  TraceCollectorStats tcs(gen->counters());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   327
  TraceMemoryManagerStats tmms(gen->kind(),gc_cause());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   328
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   329
  size_t prev_used = gen->used();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   330
  gen->stat_record()->invocations++;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   331
  gen->stat_record()->accumulated_time.start();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   332
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   333
  // Must be done anew before each collection because
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   334
  // a previous collection will do mangling and will
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   335
  // change top of some spaces.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   336
  record_gen_tops_before_GC();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   337
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   338
  if (PrintGC && Verbose) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   339
    gclog_or_tty->print("level=%d invoke=%d size=" SIZE_FORMAT,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   340
                        gen->level(),
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   341
                        gen->stat_record()->invocations,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   342
                        size * HeapWordSize);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   343
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   344
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   345
  if (run_verification && VerifyBeforeGC) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   346
    HandleMark hm;  // Discard invalid handles created during verification
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   347
    Universe::verify(" VerifyBeforeGC:");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   348
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   349
  COMPILER2_PRESENT(DerivedPointerTable::clear());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   350
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   351
  if (restore_marks_for_biased_locking) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   352
    // We perform this mark word preservation work lazily
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   353
    // because it's only at this point that we know whether we
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   354
    // absolutely have to do it; we want to avoid doing it for
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   355
    // scavenge-only collections where it's unnecessary
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   356
    BiasedLocking::preserve_marks();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   357
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   358
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   359
  // Do collection work
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   360
  {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   361
    // Note on ref discovery: For what appear to be historical reasons,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   362
    // GCH enables and disabled (by enqueing) refs discovery.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   363
    // In the future this should be moved into the generation's
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   364
    // collect method so that ref discovery and enqueueing concerns
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   365
    // are local to a generation. The collect method could return
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   366
    // an appropriate indication in the case that notification on
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   367
    // the ref lock was needed. This will make the treatment of
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   368
    // weak refs more uniform (and indeed remove such concerns
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   369
    // from GCH). XXX
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   370
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   371
    HandleMark hm;  // Discard invalid handles created during gc
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   372
    save_marks();   // save marks for all gens
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   373
    // We want to discover references, but not process them yet.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   374
    // This mode is disabled in process_discovered_references if the
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   375
    // generation does some collection work, or in
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   376
    // enqueue_discovered_references if the generation returns
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   377
    // without doing any work.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   378
    ReferenceProcessor* rp = gen->ref_processor();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   379
    // If the discovery of ("weak") refs in this generation is
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   380
    // atomic wrt other collectors in this configuration, we
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   381
    // are guaranteed to have empty discovered ref lists.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   382
    if (rp->discovery_is_atomic()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   383
      rp->enable_discovery();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   384
      rp->setup_policy(clear_soft_refs);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   385
    } else {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   386
      // collect() below will enable discovery as appropriate
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   387
    }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   388
    gen->collect(full, clear_soft_refs, size, is_tlab);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   389
    if (!rp->enqueuing_is_done()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   390
      rp->enqueue_discovered_references();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   391
    } else {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   392
      rp->set_enqueuing_is_done(false);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   393
    }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   394
    rp->verify_no_references_recorded();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   395
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   396
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   397
  COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   398
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   399
  gen->stat_record()->accumulated_time.stop();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   400
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   401
  update_gc_stats(gen->level(), full);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   402
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   403
  if (run_verification && VerifyAfterGC) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   404
    HandleMark hm;  // Discard invalid handles created during verification
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   405
    Universe::verify(" VerifyAfterGC:");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   406
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   407
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   408
  if (PrintGCDetails) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   409
    gclog_or_tty->print(":");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   410
    gen->print_heap_change(prev_used);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   411
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   412
}
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   413
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   414
void GenCollectedHeap::do_collection(bool   full,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
                                     bool   clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
                                     size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
                                     bool   is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
                                     int    max_level) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  DEBUG_ONLY(Thread* my_thread = Thread::current();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  assert(my_thread->is_VM_thread() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
         my_thread->is_ConcurrentGC_thread(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
         "incorrect thread type capability");
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   426
  assert(Heap_lock->is_locked(),
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   427
         "the requesting thread should have the Heap_lock");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  guarantee(!is_gc_active(), "collection is not reentrant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  assert(max_level < n_gens(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  if (GC_locker::check_active_before_gc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    return; // GC is disabled (e.g. JNI GetXXXCritical operation)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   435
  const bool do_clear_all_soft_refs = clear_all_soft_refs ||
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   436
                          collector_policy()->should_clear_all_soft_refs();
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   437
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   438
  ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy());
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4641
diff changeset
   439
23854
50f7f89b34e0 8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents: 23508
diff changeset
   440
  const size_t metadata_prev_used = MetaspaceAux::used_bytes();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   442
  print_heap_before_gc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    FlagSetting fl(_is_gc_active, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
    bool complete = full && (max_level == (n_gens()-1));
12630
ddf6ee008138 7166894: Add gc cause to GC logging for all collectors
brutisso
parents: 12379
diff changeset
   448
    const char* gc_cause_prefix = complete ? "Full GC" : "GC";
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
    TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
25350
6423a57e5451 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 24941
diff changeset
   450
    // The PrintGCDetails logging starts before we have incremented the GC id. We will do that later
6423a57e5451 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 24941
diff changeset
   451
    // so we can assume here that the next GC id is what we want.
6423a57e5451 8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents: 24941
diff changeset
   452
    GCTraceTime t(GCCauseString(gc_cause_prefix, gc_cause()), PrintGCDetails, false, NULL, GCId::peek());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    gc_prologue(complete);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
    increment_total_collections(complete);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
    size_t gch_prev_used = used();
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   458
    bool run_verification = total_collections() >= VerifyGCStartAt;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   460
    bool prepared_for_verification = false;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   461
    int max_level_collected = 0;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   462
    bool old_collects_young = (max_level == 1) &&
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   463
                              full &&
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   464
                              _old_gen->full_collects_younger_generations();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   465
    if (!old_collects_young &&
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   466
        _young_gen->should_collect(full, size, is_tlab)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   467
      if (run_verification && VerifyGCLevel <= 0 && VerifyBeforeGC) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   468
        prepare_for_verify();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   469
        prepared_for_verification = true;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   470
      }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   471
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   472
      assert(!_young_gen->performs_in_place_marking(), "No young generation do in place marking");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   473
      collect_generation(_young_gen,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   474
                         full,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   475
                         size,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   476
                         is_tlab,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   477
                         run_verification && VerifyGCLevel <= 0,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   478
                         do_clear_all_soft_refs,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   479
                         false);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   480
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   481
      if (size > 0 && (!is_tlab || _young_gen->supports_tlab_allocation()) &&
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   482
          size * HeapWordSize <= _young_gen->unsafe_max_alloc_nogc()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   483
        // Allocation request was met by young GC.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   484
        size = 0;
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   485
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   488
    bool must_restore_marks_for_biased_locking = false;
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   489
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   490
    if (max_level == 1 && _old_gen->should_collect(full, size, is_tlab)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   491
      if (!complete) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   492
        // The full_collections increment was missed above.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   493
        increment_total_full_collections();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   494
      }
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   495
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   496
      pre_full_gc_dump(NULL);    // do any pre full gc dumps
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   497
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   498
      if (!prepared_for_verification && run_verification &&
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   499
          VerifyGCLevel <= 1 && VerifyBeforeGC) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   500
        prepare_for_verify();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   501
      }
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   502
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   503
      assert(_old_gen->performs_in_place_marking(), "All old generations do in place marking");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   504
      collect_generation(_old_gen,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   505
                         full,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   506
                         size,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   507
                         is_tlab,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   508
                         run_verification && VerifyGCLevel <= 1,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   509
                         do_clear_all_soft_refs,
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   510
                         true);
27252
9703e3f1f92a 8061805: BACKOUT - Remove the generations array
jwilhelm
parents: 27249
diff changeset
   511
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   512
      must_restore_marks_for_biased_locking = true;
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   513
      max_level_collected = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    // Update "complete" boolean wrt what actually transpired --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    // for instance, a promotion failure could have led to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    // a whole heap collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    complete = complete || (max_level_collected == n_gens() - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2010
diff changeset
   521
    if (complete) { // We did a "major" collection
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   522
      // FIXME: See comment at pre_full_gc_dump call
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17112
diff changeset
   523
      post_full_gc_dump(NULL);   // do any post full gc dumps
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2010
diff changeset
   524
    }
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2010
diff changeset
   525
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    if (PrintGCDetails) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
      print_heap_change(gch_prev_used);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   529
      // Print metaspace info for full GC with PrintGCDetails flag.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
      if (complete) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   531
        MetaspaceAux::print_metaspace_change(metadata_prev_used);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   535
    // Adjust generation sizes.
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   536
    if (max_level_collected == 1) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   537
      _old_gen->compute_new_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   539
    _young_gen->compute_new_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    if (complete) {
16385
4a05c6d94b04 8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents: 15482
diff changeset
   542
      // Delete metaspaces for unloaded class loaders and clean up loader_data graph
4a05c6d94b04 8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used
mgerdin
parents: 15482
diff changeset
   543
      ClassLoaderDataGraph::purge();
17109
90e6c31bbbe4 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents: 17105
diff changeset
   544
      MetaspaceAux::verify_metrics();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   545
      // Resize the metaspace capacity after full collections
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   546
      MetaspaceGC::compute_new_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
      update_full_collections_completed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    // Track memory usage and detect low memory after GC finishes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    MemoryService::track_memory_usage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
    gc_epilogue(complete);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    if (must_restore_marks_for_biased_locking) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
      BiasedLocking::restore_marks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   560
  print_heap_after_gc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
2010
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1893
diff changeset
   562
#ifdef TRACESPINNING
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1893
diff changeset
   563
  ParallelTaskTerminator::print_termination_counts();
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1893
diff changeset
   564
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  return collector_policy()->satisfy_failed_allocation(size, is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11251
diff changeset
   571
void GenCollectedHeap::set_par_threads(uint t) {
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   572
  assert(t == 0 || !UseSerialGC, "Cannot have parallel threads");
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   573
  CollectedHeap::set_par_threads(t);
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   574
  set_n_termination(t);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   575
}
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   576
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   577
void GenCollectedHeap::set_n_termination(uint t) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   578
  _process_strong_tasks->set_n_threads(t);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   581
#ifdef ASSERT
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   582
class AssertNonScavengableClosure: public OopClosure {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   583
public:
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   584
  virtual void do_oop(oop* p) {
29803
6e259ffa8b72 8076231: Remove unused is_in_partial_collection()
pliden
parents: 29802
diff changeset
   585
    assert(!GenCollectedHeap::heap()->is_in_partial_collection(*p),
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   586
      "Referent should not be scavengable.");  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   587
  virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   588
};
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   589
static AssertNonScavengableClosure assert_is_non_scavengable_closure;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   590
#endif
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   591
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   592
void GenCollectedHeap::process_roots(bool activate_scope,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   593
                                     ScanningOption so,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   594
                                     OopClosure* strong_roots,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   595
                                     OopClosure* weak_roots,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   596
                                     CLDClosure* strong_cld_closure,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   597
                                     CLDClosure* weak_cld_closure,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   598
                                     CodeBlobClosure* code_roots) {
30153
596ed88949ad 8076289: Move the StrongRootsScope out of SharedHeap
brutisso
parents: 30152
diff changeset
   599
  StrongRootsScope srs(activate_scope);
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3581
diff changeset
   600
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   601
  // General roots.
29802
d485440c958a 8076225: Move the thread claim parity from SharedHeap to Thread
mgerdin
parents: 29800
diff changeset
   602
  assert(Threads::thread_claim_parity() != 0, "must have called prologue code");
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   603
  assert(code_roots != NULL, "code root closure should always be set");
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   604
  // _n_termination for _process_strong_tasks should be set up stream
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   605
  // in a method not running in a GC worker.  Otherwise the GC worker
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   606
  // could be trying to change the termination condition while the task
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   607
  // is executing in another GC worker.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   608
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   609
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_ClassLoaderDataGraph_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   610
    ClassLoaderDataGraph::roots_cld_do(strong_cld_closure, weak_cld_closure);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   611
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   612
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   613
  // Some CLDs contained in the thread frames should be considered strong.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   614
  // Don't process them if they will be processed during the ClassLoaderDataGraph phase.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   615
  CLDClosure* roots_from_clds_p = (strong_cld_closure != weak_cld_closure) ? strong_cld_closure : NULL;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   616
  // Only process code roots from thread stacks if we aren't visiting the entire CodeCache anyway
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   617
  CodeBlobClosure* roots_from_code_p = (so & SO_AllCodeCache) ? NULL : code_roots;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   618
30147
af9a41999c6e 8076314: Remove the static instance variable SharedHeap:: _sh
brutisso
parents: 29804
diff changeset
   619
  bool is_par = n_par_threads() > 0;
af9a41999c6e 8076314: Remove the static instance variable SharedHeap:: _sh
brutisso
parents: 29804
diff changeset
   620
  Threads::possibly_parallel_oops_do(is_par, strong_roots, roots_from_clds_p, roots_from_code_p);
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   621
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   622
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_Universe_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   623
    Universe::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   624
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   625
  // Global (strong) JNI handles
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   626
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_JNIHandles_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   627
    JNIHandles::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   628
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   629
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   630
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_ObjectSynchronizer_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   631
    ObjectSynchronizer::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   632
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   633
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_FlatProfiler_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   634
    FlatProfiler::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   635
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   636
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_Management_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   637
    Management::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   638
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   639
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_jvmti_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   640
    JvmtiExport::oops_do(strong_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   641
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   642
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   643
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_SystemDictionary_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   644
    SystemDictionary::roots_oops_do(strong_roots, weak_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   645
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   646
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   647
  // All threads execute the following. A specific chunk of buckets
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   648
  // from the StringTable are the individual tasks.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   649
  if (weak_roots != NULL) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   650
    if (CollectedHeap::use_parallel_gc_threads()) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   651
      StringTable::possibly_parallel_oops_do(weak_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   652
    } else {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   653
      StringTable::oops_do(weak_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   654
    }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   655
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   656
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   657
  if (!_process_strong_tasks->is_task_claimed(GCH_PS_CodeCache_oops_do)) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   658
    if (so & SO_ScavengeCodeCache) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   659
      assert(code_roots != NULL, "must supply closure for code cache");
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   660
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   661
      // We only visit parts of the CodeCache when scavenging.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   662
      CodeCache::scavenge_root_nmethods_do(code_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   663
    }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   664
    if (so & SO_AllCodeCache) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   665
      assert(code_roots != NULL, "must supply closure for code cache");
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   666
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   667
      // CMSCollector uses this to do intermediate-strength collections.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   668
      // We scan the entire code cache, since CodeCache::do_unloading is not called.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   669
      CodeCache::blobs_do(code_roots);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   670
    }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   671
    // Verify that the code cache contents are not subject to
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   672
    // movement by a scavenging collection.
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   673
    DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, !CodeBlobToOopClosure::FixRelocations));
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   674
    DEBUG_ONLY(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   675
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   676
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   677
}
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   678
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   679
void GenCollectedHeap::gen_process_roots(int level,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   680
                                         bool younger_gens_as_roots,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   681
                                         bool activate_scope,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   682
                                         ScanningOption so,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   683
                                         bool only_strong_roots,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   684
                                         OopsInGenClosure* not_older_gens,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   685
                                         OopsInGenClosure* older_gens,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   686
                                         CLDClosure* cld_closure) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   687
  const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   688
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   689
  bool is_moving_collection = false;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   690
  if (level == 0 || is_adjust_phase) {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   691
    // young collections are always moving
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   692
    is_moving_collection = true;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   693
  }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   694
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   695
  MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection);
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   696
  OopsInGenClosure* weak_roots = only_strong_roots ? NULL : not_older_gens;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   697
  CLDClosure* weak_cld_closure = only_strong_roots ? NULL : cld_closure;
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   698
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   699
  process_roots(activate_scope, so,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   700
                not_older_gens, weak_roots,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   701
                cld_closure, weak_cld_closure,
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   702
                &mark_code_closure);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  if (younger_gens_as_roots) {
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   705
    if (!_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   706
      if (level == 1) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   707
        not_older_gens->set_generation(_young_gen);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   708
        _young_gen->oop_iterate(not_older_gens);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
      not_older_gens->reset_generation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  // When collection is parallel, all threads get to cooperate to do
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  // older-gen scanning.
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   715
  if (level == 0) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   716
    older_gens->set_generation(_old_gen);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   717
    rem_set()->younger_refs_iterate(_old_gen, older_gens);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    older_gens->reset_generation();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   721
  _process_strong_tasks->all_tasks_completed();
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   722
}
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   723
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
   724
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   725
class AlwaysTrueClosure: public BoolObjectClosure {
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   726
public:
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   727
  bool do_object_b(oop p) { return true; }
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   728
};
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   729
static AlwaysTrueClosure always_true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
22882
195c8f70d605 8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents: 22552
diff changeset
   731
void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) {
29693
fac175f7a466 8075210: Refactor strong root processing in order to allow G1 to evolve separately from GenCollectedHeap
mgerdin
parents: 29684
diff changeset
   732
  JNIHandles::weak_oops_do(&always_true, root_closure);
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   733
  _young_gen->ref_processor()->weak_oops_do(root_closure);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   734
  _old_gen->ref_processor()->weak_oops_do(root_closure);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
#define GCH_SINCE_SAVE_MARKS_ITERATE_DEFN(OopClosureType, nv_suffix)    \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
void GenCollectedHeap::                                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
oop_since_save_marks_iterate(int level,                                 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
                             OopClosureType* cur,                       \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
                             OopClosureType* older) {                   \
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   742
  if (level == 0) {                                                     \
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   743
    _young_gen->oop_since_save_marks_iterate##nv_suffix(cur);           \
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   744
    _old_gen->oop_since_save_marks_iterate##nv_suffix(older);           \
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   745
  } else {                                                              \
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   746
    _old_gen->oop_since_save_marks_iterate##nv_suffix(cur);             \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  }                                                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DEFN)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
#undef GCH_SINCE_SAVE_MARKS_ITERATE_DEFN
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
bool GenCollectedHeap::no_allocs_since_save_marks(int level) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   755
  if (level == 0 && !_young_gen->no_allocs_since_save_marks()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   756
    return false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   758
  return _old_gen->no_allocs_since_save_marks();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
bool GenCollectedHeap::supports_inline_contig_alloc() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   762
  return _young_gen->supports_inline_contig_alloc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
HeapWord** GenCollectedHeap::top_addr() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   766
  return _young_gen->top_addr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
HeapWord** GenCollectedHeap::end_addr() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   770
  return _young_gen->end_addr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
// public collection interfaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
void GenCollectedHeap::collect(GCCause::Cause cause) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  if (should_do_concurrent_full_gc(cause)) {
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   777
#if INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    // mostly concurrent full collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    collect_mostly_concurrent(cause);
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   780
#else  // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
    ShouldNotReachHere();
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   782
#endif // INCLUDE_ALL_GCS
26183
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   783
  } else if (cause == GCCause::_wb_young_gc) {
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   784
    // minor collection for WhiteBox API
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   785
    collect(cause, 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
#ifdef ASSERT
26183
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   788
  if (cause == GCCause::_scavenge_alot) {
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   789
    // minor collection only
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   790
    collect(cause, 0);
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   791
  } else {
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   792
    // Stop-the-world full collection
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   793
    collect(cause, n_gens() - 1);
bbe259d3c8bc 8055098: WB API should be extended to provide information about size and age of object.
tschatzl
parents: 25730
diff changeset
   794
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    // Stop-the-world full collection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    collect(cause, n_gens() - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
void GenCollectedHeap::collect(GCCause::Cause cause, int max_level) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  // The caller doesn't have the Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  MutexLocker ml(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  collect_locked(cause, max_level);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
void GenCollectedHeap::collect_locked(GCCause::Cause cause) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  // The caller has the Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  assert(Heap_lock->owned_by_self(), "this thread should own the Heap_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  collect_locked(cause, n_gens() - 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
// this is the private collection interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
// The Heap_lock is expected to be held on entry.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  // Read the GC count while holding the Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  unsigned int gc_count_before      = total_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  unsigned int full_gc_count_before = total_full_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
    MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
    VM_GenCollectFull op(gc_count_before, full_gc_count_before,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
                         cause, max_level);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   830
#if INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
bool GenCollectedHeap::create_cms_collector() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   833
  assert(_old_gen->kind() == Generation::ConcurrentMarkSweep,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
         "Unexpected generation kinds");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  // Skip two header words in the block content verification
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  CMSCollector* collector = new CMSCollector(
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   838
    (ConcurrentMarkSweepGeneration*)_old_gen,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    _rem_set->as_CardTableRS(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
    (ConcurrentMarkSweepPolicy*) collector_policy());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  if (collector == NULL || !collector->completed_initialization()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    if (collector) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
      delete collector;  // Be nice in embedded situation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    vm_shutdown_during_initialization("Could not create CMS collector");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  return true;  // success
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  MutexLocker ml(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  // Read the GC counts while holding the Heap_lock
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  unsigned int full_gc_count_before = total_full_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  unsigned int gc_count_before      = total_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
    MutexUnlocker mu(Heap_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
    VM_GenCollectFullConcurrent op(gc_count_before, full_gc_count_before, cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
    VMThread::execute(&op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
}
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
   865
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   867
void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   868
   do_full_collection(clear_all_soft_refs, _n_gens - 1);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   869
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
                                          int max_level) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  int local_max_level;
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   874
  if (!incremental_collection_will_fail(false /* don't consult_young */) &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
      gc_cause() == GCCause::_gc_locker) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
    local_max_level = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    local_max_level = max_level;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  do_collection(true                 /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
                clear_all_soft_refs  /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
                0                    /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
                false                /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
                local_max_level      /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  // Hack XXX FIX ME !!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  // A scavenge may not have been attempted, or may have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  // been attempted and failed, because the old gen was too full
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  if (local_max_level == 0 && gc_cause() == GCCause::_gc_locker &&
7419
263dd4e89b9d 7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
ysr
parents: 7397
diff changeset
   890
      incremental_collection_will_fail(false /* don't consult_young */)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
    if (PrintGCDetails) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
      gclog_or_tty->print_cr("GC locker: Trying a full collection "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
                             "because scavenge failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
    // This time allow the old gen to be collected as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
    do_collection(true                 /* full */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
                  clear_all_soft_refs  /* clear_all_soft_refs */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
                  0                    /* size */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
                  false                /* is_tlab */,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
                  n_gens() - 1         /* max_level */);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   904
bool GenCollectedHeap::is_in_young(oop p) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   905
  bool result = ((HeapWord*)p) < _old_gen->reserved().start();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   906
  assert(result == _young_gen->is_in_reserved(p),
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24353
diff changeset
   907
         err_msg("incorrect test - result=%d, p=" INTPTR_FORMAT, result, p2i((void*)p)));
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   908
  return result;
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   909
}
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   910
11247
d6faa02b3802 7121373: Clean up CollectedHeap::is_in
stefank
parents: 10997
diff changeset
   911
// Returns "TRUE" iff "p" points into the committed areas of the heap.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
bool GenCollectedHeap::is_in(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  #ifndef ASSERT
16680
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   914
  guarantee(VerifyBeforeGC      ||
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   915
            VerifyDuringGC      ||
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   916
            VerifyBeforeExit    ||
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   917
            VerifyDuringStartup ||
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   918
            PrintAssembly       ||
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   919
            tty->count() != 0   ||   // already printing
960505df90e7 8011343: Add new flag for verifying the heap during startup
johnc
parents: 16385
diff changeset
   920
            VerifyAfterGC       ||
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5906
diff changeset
   921
    VMError::fatal_error_in_progress(), "too expensive");
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5906
diff changeset
   922
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  #endif
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   924
  return _young_gen->is_in(p) || _old_gen->is_in(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   927
#ifdef ASSERT
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   928
// Don't implement this by using is_in_young().  This method is used
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   929
// in some cases to check that is_in_young() is correct.
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   930
bool GenCollectedHeap::is_in_partial_collection(const void* p) {
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   931
  assert(is_in_reserved(p) || p == NULL,
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   932
    "Does not work if address is non-null and outside of the heap");
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   933
  return p < _young_gen->reserved().end() && p != NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
}
9935
51267b5e1a3d 7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents: 9623
diff changeset
   935
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   937
void GenCollectedHeap::oop_iterate_no_header(OopClosure* cl) {
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   938
  NoHeaderExtendedOopClosure no_header_cl(cl);
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   939
  oop_iterate(&no_header_cl);
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   940
}
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 30147
diff changeset
   941
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
   942
void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   943
  _young_gen->oop_iterate(cl);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   944
  _old_gen->oop_iterate(cl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
void GenCollectedHeap::object_iterate(ObjectClosure* cl) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   948
  _young_gen->object_iterate(cl);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   949
  _old_gen->object_iterate(cl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1610
diff changeset
   952
void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   953
  _young_gen->safe_object_iterate(cl);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   954
  _old_gen->safe_object_iterate(cl);
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1610
diff changeset
   955
}
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1610
diff changeset
   956
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
Space* GenCollectedHeap::space_containing(const void* addr) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   958
  Space* res = _young_gen->space_containing(addr);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   959
  if (res != NULL) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   960
    return res;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   962
  res = _old_gen->space_containing(addr);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   963
  assert(res != NULL, "Could not find containing space");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   964
  return res;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
HeapWord* GenCollectedHeap::block_start(const void* addr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
  assert(is_in_reserved(addr), "block_start of address outside of heap");
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   969
  if (_young_gen->is_in_reserved(addr)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   970
    assert(_young_gen->is_in(addr), "addr should be in allocated part of generation");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   971
    return _young_gen->block_start(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   973
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   974
  assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   975
  assert(_old_gen->is_in(addr), "addr should be in allocated part of generation");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   976
  return _old_gen->block_start(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
size_t GenCollectedHeap::block_size(const HeapWord* addr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
  assert(is_in_reserved(addr), "block_size of address outside of heap");
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   981
  if (_young_gen->is_in_reserved(addr)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   982
    assert(_young_gen->is_in(addr), "addr should be in allocated part of generation");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   983
    return _young_gen->block_size(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   985
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   986
  assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   987
  assert(_old_gen->is_in(addr), "addr should be in allocated part of generation");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   988
  return _old_gen->block_size(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  assert(is_in_reserved(addr), "block_is_obj of address outside of heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  assert(block_start(addr) == addr, "addr must be a block start");
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   994
  if (_young_gen->is_in_reserved(addr)) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   995
    return _young_gen->block_is_obj(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   997
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   998
  assert(_old_gen->is_in_reserved(addr), "Some generation should contain the address");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
   999
  return _old_gen->block_is_obj(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
bool GenCollectedHeap::supports_tlab_allocation() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1003
  assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1004
  return _young_gen->supports_tlab_allocation();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
size_t GenCollectedHeap::tlab_capacity(Thread* thr) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1008
  assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1009
  if (_young_gen->supports_tlab_allocation()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1010
    return _young_gen->tlab_capacity();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1012
  return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1015
size_t GenCollectedHeap::tlab_used(Thread* thr) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1016
  assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1017
  if (_young_gen->supports_tlab_allocation()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1018
    return _young_gen->tlab_used();
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1019
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1020
  return 0;
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1021
}
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22551
diff changeset
  1022
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
size_t GenCollectedHeap::unsafe_max_tlab_alloc(Thread* thr) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1024
  assert(!_old_gen->supports_tlab_allocation(), "Old gen supports TLAB allocation?!");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1025
  if (_young_gen->supports_tlab_allocation()) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1026
    return _young_gen->unsafe_max_tlab_alloc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1028
  return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
HeapWord* GenCollectedHeap::allocate_new_tlab(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  bool gc_overhead_limit_was_exceeded;
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
  1033
  return collector_policy()->mem_allocate_work(size /* size */,
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
  1034
                                               true /* is_tlab */,
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
  1035
                                               &gc_overhead_limit_was_exceeded);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
// Requires "*prev_ptr" to be non-NULL.  Deletes and a block of minimal size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// from the list headed by "*prev_ptr".
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
static ScratchBlock *removeSmallestScratch(ScratchBlock **prev_ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  bool first = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  size_t min_size = 0;   // "first" makes this conceptually infinite.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  ScratchBlock **smallest_ptr, *smallest;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  ScratchBlock  *cur = *prev_ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  while (cur) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
    assert(*prev_ptr == cur, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
    if (first || cur->num_words < min_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
      smallest_ptr = prev_ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
      smallest     = cur;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
      min_size     = smallest->num_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
      first        = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
    prev_ptr = &cur->next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
    cur     =  cur->next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  smallest      = *smallest_ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  *smallest_ptr = smallest->next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  return smallest;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
// Sort the scratch block list headed by res into decreasing size order,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
// and set "res" to the result.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
static void sort_scratch_list(ScratchBlock*& list) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  ScratchBlock* sorted = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  ScratchBlock* unsorted = list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  while (unsorted) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
    ScratchBlock *smallest = removeSmallestScratch(&unsorted);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
    smallest->next  = sorted;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
    sorted          = smallest;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  list = sorted;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
ScratchBlock* GenCollectedHeap::gather_scratch(Generation* requestor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
                                               size_t max_alloc_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  ScratchBlock* res = NULL;
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1077
  _young_gen->contribute_scratch(res, requestor, max_alloc_words);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1078
  _old_gen->contribute_scratch(res, requestor, max_alloc_words);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  sort_scratch_list(res);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1083
void GenCollectedHeap::release_scratch() {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1084
  _young_gen->reset_scratch();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1085
  _old_gen->reset_scratch();
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1086
}
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1087
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
class GenPrepareForVerifyClosure: public GenCollectedHeap::GenClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  void do_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
    gen->prepare_for_verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
void GenCollectedHeap::prepare_for_verify() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  ensure_parsability(false);        // no need to retire TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  GenPrepareForVerifyClosure blk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  generation_iterate(&blk, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
void GenCollectedHeap::generation_iterate(GenClosure* cl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
                                          bool old_to_young) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  if (old_to_young) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1103
    cl->do_generation(_old_gen);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1104
    cl->do_generation(_young_gen);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  } else {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1106
    cl->do_generation(_young_gen);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1107
    cl->do_generation(_old_gen);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
bool GenCollectedHeap::is_maximal_no_gc() const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1112
  return _young_gen->is_maximal_no_gc() && _old_gen->is_maximal_no_gc();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
void GenCollectedHeap::save_marks() {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1116
  _young_gen->save_marks();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1117
  _old_gen->save_marks();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
GenCollectedHeap* GenCollectedHeap::heap() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  return _gch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
void GenCollectedHeap::prepare_for_compaction() {
19286
48394008c803 8022800: Use specific generations rather than generation iteration
brutisso
parents: 18687
diff changeset
  1128
  guarantee(_n_gens = 2, "Wrong number of generations");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
  // Start by compacting into same gen.
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1130
  CompactPoint cp(_old_gen);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1131
  _old_gen->prepare_for_compaction(&cp);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1132
  _young_gen->prepare_for_compaction(&cp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
GCStats* GenCollectedHeap::gc_stats(int level) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1136
  if (level == 0) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1137
    return _young_gen->gc_stats();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1138
  } else {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1139
    return _old_gen->gc_stats();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1140
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
12379
2cf45b79ce3a 4988100: oop_verify_old_oop appears to be dead
brutisso
parents: 11636
diff changeset
  1143
void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1144
  if (!silent) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1145
    gclog_or_tty->print("%s", _old_gen->name());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1146
    gclog_or_tty->print(" ");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  }
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1148
  _old_gen->verify();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1149
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1150
  if (!silent) {
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1151
    gclog_or_tty->print("%s", _young_gen->name());
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1152
    gclog_or_tty->print(" ");
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1153
  }
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1154
  _young_gen->verify();
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1155
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  if (!silent) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
    gclog_or_tty->print("remset ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  rem_set()->verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
void GenCollectedHeap::print_on(outputStream* st) const {
29200
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1163
  _young_gen->print_on(st);
5e480434bef4 8061802: REDO - Remove the generations array
jwilhelm
parents: 29081
diff changeset
  1164
  _old_gen->print_on(st);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
  1165
  MetaspaceAux::print_on(st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
  if (workers() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
    workers()->threads_do(tc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
  1172
#if INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  if (UseConcMarkSweepGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
    ConcurrentMarkSweepThread::threads_do(tc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
  1176
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
void GenCollectedHeap::print_gc_threads_on(outputStream* st) const {
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
  1180
#if INCLUDE_ALL_GCS
27898
813ad96387b3 8065972: Remove support for ParNew+SerialOld and DefNew+CMS
brutisso
parents: 27887
diff changeset
  1181
  if (UseConcMarkSweepGC) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
    workers()->print_worker_threads_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
    ConcurrentMarkSweepThread::print_all_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14076
diff changeset
  1185
#endif // INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1188
void GenCollectedHeap::print_on_error(outputStream* st) const {
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1189
  this->CollectedHeap::print_on_error(st);
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1190
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1191
#if INCLUDE_ALL_GCS
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1192
  if (UseConcMarkSweepGC) {
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1193
    st->cr();
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1194
    CMSCollector::print_on_error(st);
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1195
  }
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1196
#endif // INCLUDE_ALL_GCS
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1197
}
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16680
diff changeset
  1198
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
void GenCollectedHeap::print_tracing_info() const {
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24424
diff changeset
  1200
  if (TraceYoungGenTime) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
  1201
    _young_gen->print_summary_info();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  }
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24424
diff changeset
  1203
  if (TraceOldGenTime) {
29684
a36d90acae41 8057632: Remove auxiliary code used to handle the generations array
jwilhelm
parents: 29200
diff changeset
  1204
    _old_gen->print_summary_info();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
void GenCollectedHeap::print_heap_change(size_t prev_used) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  if (PrintGCDetails && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
    gclog_or_tty->print(" "  SIZE_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
                        "->" SIZE_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
                        "("  SIZE_FORMAT ")",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
                        prev_used, used(), capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
    gclog_or_tty->print(" "  SIZE_FORMAT "K"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
                        "->" SIZE_FORMAT "K"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
                        "("  SIZE_FORMAT "K)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
                        prev_used / K, used() / K, capacity() / K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
class GenGCPrologueClosure: public GenCollectedHeap::GenClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  bool _full;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  void do_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    gen->gc_prologue(_full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  GenGCPrologueClosure(bool full) : _full(full) {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
void GenCollectedHeap::gc_prologue(bool full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  always_do_update_barrier = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  // Fill TLAB's and such
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  CollectedHeap::accumulate_statistics_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  ensure_parsability(true);   // retire TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  // Walk generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  GenGCPrologueClosure blk(full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  generation_iterate(&blk, false);  // not old-to-young.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
class GenGCEpilogueClosure: public GenCollectedHeap::GenClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  bool _full;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
  void do_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
    gen->gc_epilogue(_full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  GenGCEpilogueClosure(bool full) : _full(full) {};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
void GenCollectedHeap::gc_epilogue(bool full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  assert(DerivedPointerTable::is_empty(), "derived pointer present");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  size_t actual_gap = pointer_delta((HeapWord*) (max_uintx-3), *(end_addr()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
  guarantee(actual_gap > (size_t)FastAllocateSizeLimit, "inline allocation wraps");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
#endif /* COMPILER2 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
  GenGCEpilogueClosure blk(full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
  generation_iterate(&blk, false);  // not old-to-young.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
10022
377345fb5fb5 7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents: 9997
diff changeset
  1267
  if (!CleanChunkPoolAsync) {
377345fb5fb5 7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents: 9997
diff changeset
  1268
    Chunk::clean_chunk_pool();
377345fb5fb5 7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents: 9997
diff changeset
  1269
  }
377345fb5fb5 7061204: clean the chunk table synchronously in embedded builds
jcoomes
parents: 9997
diff changeset
  1270
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
  1271
  MetaspaceCounters::update_performance_counters();
19322
e35f9ed4f081 8014659: NPG: performance counters for compressed klass space
ehelin
parents: 19286
diff changeset
  1272
  CompressedClassSpaceCounters::update_performance_counters();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 12781
diff changeset
  1273
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  always_do_update_barrier = UseConcMarkSweepGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1277
#ifndef PRODUCT
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1278
class GenGCSaveTopsBeforeGCClosure: public GenCollectedHeap::GenClosure {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1279
 private:
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1280
 public:
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1281
  void do_generation(Generation* gen) {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1282
    gen->record_spaces_top();
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1283
  }
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1284
};
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1285
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1286
void GenCollectedHeap::record_gen_tops_before_GC() {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1287
  if (ZapUnusedHeapArea) {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1288
    GenGCSaveTopsBeforeGCClosure blk;
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1289
    generation_iterate(&blk, false);  // not old-to-young.
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1290
  }
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1291
}
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1292
#endif  // not PRODUCT
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 360
diff changeset
  1293
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  void do_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
    gen->ensure_parsability();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
void GenCollectedHeap::ensure_parsability(bool retire_tlabs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
  CollectedHeap::ensure_parsability(retire_tlabs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
  GenEnsureParsabilityClosure ep_cl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  generation_iterate(&ep_cl, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
19286
48394008c803 8022800: Use specific generations rather than generation iteration
brutisso
parents: 18687
diff changeset
  1307
oop GenCollectedHeap::handle_failed_promotion(Generation* old_gen,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
                                              oop obj,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1309
                                              size_t obj_size) {
19286
48394008c803 8022800: Use specific generations rather than generation iteration
brutisso
parents: 18687
diff changeset
  1310
  guarantee(old_gen->level() == 1, "We only get here with an old generation");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  assert(obj_size == (size_t)obj->size(), "bad obj_size passed in");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  HeapWord* result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
19286
48394008c803 8022800: Use specific generations rather than generation iteration
brutisso
parents: 18687
diff changeset
  1314
  result = old_gen->expand_and_allocate(obj_size, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
    Copy::aligned_disjoint_words((HeapWord*)obj, result, obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  return oop(result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
class GenTimeOfLastGCClosure: public GenCollectedHeap::GenClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  jlong _time;   // in ms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  jlong _now;    // in ms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  GenTimeOfLastGCClosure(jlong now) : _time(now), _now(now) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  jlong time() { return _time; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  void do_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
    _time = MIN2(_time, gen->time_of_last_gc(_now));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
jlong GenCollectedHeap::millis_since_last_gc() {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22550
diff changeset
  1337
  // We need a monotonically non-decreasing time in ms but
11251
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1338
  // os::javaTimeMillis() does not guarantee monotonicity.
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1339
  jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  GenTimeOfLastGCClosure tolgc_cl(now);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  // iterate over generations getting the oldest
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  // time that a generation was collected
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  generation_iterate(&tolgc_cl, false);
11251
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1344
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1345
  // javaTimeNanos() is guaranteed to be monotonically non-decreasing
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1346
  // provided the underlying platform provides such a time source
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1347
  // (and it is bug free). So we still have to guard against getting
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11247
diff changeset
  1348
  // back a time later than 'now'.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
  jlong retVal = now - tolgc_cl.time();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  if (retVal < 0) {
29800
fa5f7a2bf717 8076073: shared: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29794
diff changeset
  1351
    NOT_PRODUCT(warning("time warp: " JLONG_FORMAT, retVal);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  return retVal;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
}