hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp
author goetz
Thu, 08 May 2014 15:37:17 +0200
changeset 24487 71ff0bd674eb
parent 24424 2658d7834c6e
child 24489 de383df95d5c
permissions -rw-r--r--
8042737: Introduce umbrella header prefetch.inline.hpp Reviewed-by: twisti, stefank
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     1
/*
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
     2
 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     4
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     7
 * published by the Free Software Foundation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     8
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    13
 * accompanied this code).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    14
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5542
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5542
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: 5542
diff changeset
    21
 * questions.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    22
 *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    23
 */
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    26
#include "classfile/symbolTable.hpp"
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
    27
#include "gc_implementation/g1/concurrentMark.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    28
#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    29
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    30
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
10523
cdb54c167ab0 7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents: 10280
diff changeset
    31
#include "gc_implementation/g1/g1ErgoVerbose.hpp"
12378
ed44b9ecfa2f 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 12272
diff changeset
    32
#include "gc_implementation/g1/g1Log.hpp"
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
    33
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    34
#include "gc_implementation/g1/g1RemSet.hpp"
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
    35
#include "gc_implementation/g1/heapRegion.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    36
#include "gc_implementation/g1/heapRegionRemSet.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    37
#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
7896
08aadd7aa3ee 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 7657
diff changeset
    38
#include "gc_implementation/shared/vmGCOperations.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
    39
#include "gc_implementation/shared/gcTimer.hpp"
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
    40
#include "gc_implementation/shared/gcTrace.hpp"
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
    41
#include "gc_implementation/shared/gcTraceTime.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    42
#include "memory/genOopClosures.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    43
#include "memory/referencePolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    44
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    45
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    46
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6982
diff changeset
    47
#include "runtime/java.hpp"
24487
71ff0bd674eb 8042737: Introduce umbrella header prefetch.inline.hpp
goetz
parents: 24424
diff changeset
    48
#include "runtime/prefetch.inline.hpp"
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12508
diff changeset
    49
#include "services/memTracker.hpp"
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    50
11575
d7a2e4295dc9 7130334: G1: Change comments and error messages that refer to CMS in g1/concurrentMark.cpp/hpp
brutisso
parents: 11574
diff changeset
    51
// Concurrent marking bit map wrapper
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    52
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
    53
CMBitMapRO::CMBitMapRO(int shifter) :
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
    54
  _bm(),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    55
  _shifter(shifter) {
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
    56
  _bmStartWord = 0;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
    57
  _bmWordSize = 0;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    58
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    59
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    60
HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    61
                                               HeapWord* limit) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    62
  // First we must round addr *up* to a possible object boundary.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    63
  addr = (HeapWord*)align_size_up((intptr_t)addr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    64
                                  HeapWordSize << _shifter);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    65
  size_t addrOffset = heapWordToOffset(addr);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    66
  if (limit == NULL) {
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    67
    limit = _bmStartWord + _bmWordSize;
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    68
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    69
  size_t limitOffset = heapWordToOffset(limit);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    70
  size_t nextOffset = _bm.get_next_one_offset(addrOffset, limitOffset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    71
  HeapWord* nextAddr = offsetToHeapWord(nextOffset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    72
  assert(nextAddr >= addr, "get_next_one postcondition");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    73
  assert(nextAddr == limit || isMarked(nextAddr),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    74
         "get_next_one postcondition");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    75
  return nextAddr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    76
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    77
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    78
HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(HeapWord* addr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    79
                                                 HeapWord* limit) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    80
  size_t addrOffset = heapWordToOffset(addr);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    81
  if (limit == NULL) {
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    82
    limit = _bmStartWord + _bmWordSize;
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
    83
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    84
  size_t limitOffset = heapWordToOffset(limit);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    85
  size_t nextOffset = _bm.get_next_zero_offset(addrOffset, limitOffset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    86
  HeapWord* nextAddr = offsetToHeapWord(nextOffset);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    87
  assert(nextAddr >= addr, "get_next_one postcondition");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    88
  assert(nextAddr == limit || !isMarked(nextAddr),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    89
         "get_next_one postcondition");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    90
  return nextAddr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    91
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    92
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    93
int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    94
  assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    95
  return (int) (diff >> _shifter);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    96
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    97
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
    98
#ifndef PRODUCT
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
    99
bool CMBitMapRO::covers(ReservedSpace heap_rs) const {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   100
  // assert(_bm.map() == _virtual_space.low(), "map inconsistency");
13752
92f03fcf979a 7197906: BlockOffsetArray::power_to_cards_back() needs to handle > 32 bit shifts
brutisso
parents: 13728
diff changeset
   101
  assert(((size_t)_bm.size() * ((size_t)1 << _shifter)) == _bmWordSize,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   102
         "size inconsistency");
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   103
  return _bmStartWord == (HeapWord*)(heap_rs.base()) &&
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   104
         _bmWordSize  == heap_rs.size()>>LogHeapWordSize;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   105
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   106
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   107
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
   108
void CMBitMapRO::print_on_error(outputStream* st, const char* prefix) const {
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
   109
  _bm.print_on_error(st, prefix);
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
   110
}
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
   111
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   112
bool CMBitMap::allocate(ReservedSpace heap_rs) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   113
  _bmStartWord = (HeapWord*)(heap_rs.base());
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   114
  _bmWordSize  = heap_rs.size()/HeapWordSize;    // heap_rs.size() is in bytes
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   115
  ReservedSpace brs(ReservedSpace::allocation_align_size_up(
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   116
                     (_bmWordSize >> (_shifter + LogBitsPerByte)) + 1));
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   117
  if (!brs.is_reserved()) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   118
    warning("ConcurrentMark marking bit map allocation failure");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   119
    return false;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   120
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   121
  MemTracker::record_virtual_memory_type((address)brs.base(), mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   122
  // For now we'll just commit all of the bit map up front.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   123
  // Later on we'll try to be more parsimonious with swap.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   124
  if (!_virtual_space.initialize(brs, brs.size())) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   125
    warning("ConcurrentMark marking bit map backing store failure");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   126
    return false;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   127
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   128
  assert(_virtual_space.committed_size() == brs.size(),
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   129
         "didn't reserve backing store for all of concurrent marking bit map?");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   130
  _bm.set_map((uintptr_t*)_virtual_space.low());
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   131
  assert(_virtual_space.committed_size() << (_shifter + LogBitsPerByte) >=
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   132
         _bmWordSize, "inconsistency in bit map sizing");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   133
  _bm.set_size(_bmWordSize >> _shifter);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   134
  return true;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   135
}
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   136
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   137
void CMBitMap::clearAll() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   138
  _bm.clear();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   139
  return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   140
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   141
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   142
void CMBitMap::markRange(MemRegion mr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   143
  mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   144
  assert(!mr.is_empty(), "unexpected empty region");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   145
  assert((offsetToHeapWord(heapWordToOffset(mr.end())) ==
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   146
          ((HeapWord *) mr.end())),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   147
         "markRange memory region end is not card aligned");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   148
  // convert address range into offset range
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   149
  _bm.at_put_range(heapWordToOffset(mr.start()),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   150
                   heapWordToOffset(mr.end()), true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   151
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   152
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   153
void CMBitMap::clearRange(MemRegion mr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   154
  mr.intersection(MemRegion(_bmStartWord, _bmWordSize));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   155
  assert(!mr.is_empty(), "unexpected empty region");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   156
  // convert address range into offset range
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   157
  _bm.at_put_range(heapWordToOffset(mr.start()),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   158
                   heapWordToOffset(mr.end()), false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   159
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   160
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   161
MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   162
                                            HeapWord* end_addr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   163
  HeapWord* start = getNextMarkedWordAddress(addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   164
  start = MIN2(start, end_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   165
  HeapWord* end   = getNextUnmarkedWordAddress(start);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   166
  end = MIN2(end, end_addr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   167
  assert(start <= end, "Consistency check");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   168
  MemRegion mr(start, end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   169
  if (!mr.is_empty()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   170
    clearRange(mr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   171
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   172
  return mr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   173
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   174
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   175
CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   176
  _base(NULL), _cm(cm)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   177
#ifdef ASSERT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   178
  , _drain_in_progress(false)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   179
  , _drain_in_progress_yields(false)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   180
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   181
{}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   182
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   183
bool CMMarkStack::allocate(size_t capacity) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   184
  // allocate a stack of the requisite depth
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   185
  ReservedSpace rs(ReservedSpace::allocation_align_size_up(capacity * sizeof(oop)));
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   186
  if (!rs.is_reserved()) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   187
    warning("ConcurrentMark MarkStack allocation failure");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   188
    return false;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   189
  }
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   190
  MemTracker::record_virtual_memory_type((address)rs.base(), mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   191
  if (!_virtual_space.initialize(rs, rs.size())) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   192
    warning("ConcurrentMark MarkStack backing store failure");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   193
    // Release the virtual memory reserved for the marking stack
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   194
    rs.release();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   195
    return false;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   196
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   197
  assert(_virtual_space.committed_size() == rs.size(),
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   198
         "Didn't reserve backing store for all of ConcurrentMark stack?");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   199
  _base = (oop*) _virtual_space.low();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   200
  setEmpty();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   201
  _capacity = (jint) capacity;
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   202
  _saved_index = -1;
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   203
  _should_expand = false;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   204
  NOT_PRODUCT(_max_depth = 0);
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   205
  return true;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   206
}
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   207
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   208
void CMMarkStack::expand() {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   209
  // Called, during remark, if we've overflown the marking stack during marking.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   210
  assert(isEmpty(), "stack should been emptied while handling overflow");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   211
  assert(_capacity <= (jint) MarkStackSizeMax, "stack bigger than permitted");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   212
  // Clear expansion flag
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   213
  _should_expand = false;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   214
  if (_capacity == (jint) MarkStackSizeMax) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   215
    if (PrintGCDetails && Verbose) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   216
      gclog_or_tty->print_cr(" (benign) Can't expand marking stack capacity, at max size limit");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   217
    }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   218
    return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   219
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   220
  // Double capacity if possible
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   221
  jint new_capacity = MIN2(_capacity*2, (jint) MarkStackSizeMax);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   222
  // Do not give up existing stack until we have managed to
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   223
  // get the double capacity that we desired.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   224
  ReservedSpace rs(ReservedSpace::allocation_align_size_up(new_capacity *
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   225
                                                           sizeof(oop)));
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   226
  if (rs.is_reserved()) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   227
    // Release the backing store associated with old stack
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   228
    _virtual_space.release();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   229
    // Reinitialize virtual space for new stack
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   230
    if (!_virtual_space.initialize(rs, rs.size())) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   231
      fatal("Not enough swap for expanded marking stack capacity");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   232
    }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   233
    _base = (oop*)(_virtual_space.low());
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   234
    _index = 0;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   235
    _capacity = new_capacity;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   236
  } else {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   237
    if (PrintGCDetails && Verbose) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   238
      // Failed to double capacity, continue;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   239
      gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from "
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   240
                          SIZE_FORMAT"K to " SIZE_FORMAT"K",
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   241
                          _capacity / K, new_capacity / K);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   242
    }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   243
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   244
}
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   245
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   246
void CMMarkStack::set_should_expand() {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   247
  // If we're resetting the marking state because of an
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   248
  // marking stack overflow, record that we should, if
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   249
  // possible, expand the stack.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   250
  _should_expand = _cm->has_overflown();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   251
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   252
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   253
CMMarkStack::~CMMarkStack() {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   254
  if (_base != NULL) {
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   255
    _base = NULL;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   256
    _virtual_space.release();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   257
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   258
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   259
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   260
void CMMarkStack::par_push(oop ptr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   261
  while (true) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   262
    if (isFull()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   263
      _overflow = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   264
      return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   265
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   266
    // Otherwise...
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   267
    jint index = _index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   268
    jint next_index = index+1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   269
    jint res = Atomic::cmpxchg(next_index, &_index, index);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   270
    if (res == index) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   271
      _base[index] = ptr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   272
      // Note that we don't maintain this atomically.  We could, but it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   273
      // doesn't seem necessary.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   274
      NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   275
      return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   276
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   277
    // Otherwise, we need to try again.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   278
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   279
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   280
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   281
void CMMarkStack::par_adjoin_arr(oop* ptr_arr, int n) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   282
  while (true) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   283
    if (isFull()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   284
      _overflow = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   285
      return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   286
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   287
    // Otherwise...
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   288
    jint index = _index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   289
    jint next_index = index + n;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   290
    if (next_index > _capacity) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   291
      _overflow = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   292
      return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   293
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   294
    jint res = Atomic::cmpxchg(next_index, &_index, index);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   295
    if (res == index) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   296
      for (int i = 0; i < n; i++) {
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   297
        int  ind = index + i;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   298
        assert(ind < _capacity, "By overflow test above.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   299
        _base[ind] = ptr_arr[i];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   300
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   301
      NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   302
      return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   303
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   304
    // Otherwise, we need to try again.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   305
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   306
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   307
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   308
void CMMarkStack::par_push_arr(oop* ptr_arr, int n) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   309
  MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   310
  jint start = _index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   311
  jint next_index = start + n;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   312
  if (next_index > _capacity) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   313
    _overflow = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   314
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   315
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   316
  // Otherwise.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   317
  _index = next_index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   318
  for (int i = 0; i < n; i++) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   319
    int ind = start + i;
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   320
    assert(ind < _capacity, "By overflow test above.");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   321
    _base[ind] = ptr_arr[i];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   322
  }
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   323
  NOT_PRODUCT(_max_depth = MAX2(_max_depth, next_index));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   324
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   325
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   326
bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   327
  MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   328
  jint index = _index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   329
  if (index == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   330
    *n = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   331
    return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   332
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   333
    int k = MIN2(max, index);
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   334
    jint  new_ind = index - k;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   335
    for (int j = 0; j < k; j++) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   336
      ptr_arr[j] = _base[new_ind + j];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   337
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   338
    _index = new_ind;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   339
    *n = k;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   340
    return true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   341
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   342
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   343
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   344
template<class OopClosureClass>
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   345
bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   346
  assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   347
         || SafepointSynchronize::is_at_safepoint(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   348
         "Drain recursion must be yield-safe.");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   349
  bool res = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   350
  debug_only(_drain_in_progress = true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   351
  debug_only(_drain_in_progress_yields = yield_after);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   352
  while (!isEmpty()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   353
    oop newOop = pop();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   354
    assert(G1CollectedHeap::heap()->is_in_reserved(newOop), "Bad pop");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   355
    assert(newOop->is_oop(), "Expected an oop");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   356
    assert(bm == NULL || bm->isMarked((HeapWord*)newOop),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   357
           "only grey objects on this stack");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   358
    newOop->oop_iterate(cl);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   359
    if (yield_after && _cm->do_yield_check()) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   360
      res = false;
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   361
      break;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   362
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   363
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   364
  debug_only(_drain_in_progress = false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   365
  return res;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   366
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   367
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   368
void CMMarkStack::note_start_of_gc() {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   369
  assert(_saved_index == -1,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   370
         "note_start_of_gc()/end_of_gc() bracketed incorrectly");
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   371
  _saved_index = _index;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   372
}
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   373
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   374
void CMMarkStack::note_end_of_gc() {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   375
  // This is intentionally a guarantee, instead of an assert. If we
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   376
  // accidentally add something to the mark stack during GC, it
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   377
  // will be a correctness issue so it's better if we crash. we'll
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   378
  // only check this once per GC anyway, so it won't be a performance
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   379
  // issue in any way.
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   380
  guarantee(_saved_index == _index,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   381
            err_msg("saved index: %d index: %d", _saved_index, _index));
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   382
  _saved_index = -1;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   383
}
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   384
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   385
void CMMarkStack::oops_do(OopClosure* f) {
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   386
  assert(_saved_index == _index,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   387
         err_msg("saved index: %d index: %d", _saved_index, _index));
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   388
  for (int i = 0; i < _index; i += 1) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   389
    f->do_oop(&_base[i]);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   390
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   391
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   392
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   393
bool ConcurrentMark::not_yet_marked(oop obj) const {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13336
diff changeset
   394
  return _g1h->is_obj_ill(obj);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   395
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   396
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   397
CMRootRegions::CMRootRegions() :
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   398
  _young_list(NULL), _cm(NULL), _scan_in_progress(false),
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   399
  _should_abort(false),  _next_survivor(NULL) { }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   400
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   401
void CMRootRegions::init(G1CollectedHeap* g1h, ConcurrentMark* cm) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   402
  _young_list = g1h->young_list();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   403
  _cm = cm;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   404
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   405
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   406
void CMRootRegions::prepare_for_scan() {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   407
  assert(!scan_in_progress(), "pre-condition");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   408
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   409
  // Currently, only survivors can be root regions.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   410
  assert(_next_survivor == NULL, "pre-condition");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   411
  _next_survivor = _young_list->first_survivor_region();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   412
  _scan_in_progress = (_next_survivor != NULL);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   413
  _should_abort = false;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   414
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   415
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   416
HeapRegion* CMRootRegions::claim_next() {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   417
  if (_should_abort) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   418
    // If someone has set the should_abort flag, we return NULL to
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   419
    // force the caller to bail out of their loop.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   420
    return NULL;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   421
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   422
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   423
  // Currently, only survivors can be root regions.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   424
  HeapRegion* res = _next_survivor;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   425
  if (res != NULL) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   426
    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   427
    // Read it again in case it changed while we were waiting for the lock.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   428
    res = _next_survivor;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   429
    if (res != NULL) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   430
      if (res == _young_list->last_survivor_region()) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   431
        // We just claimed the last survivor so store NULL to indicate
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   432
        // that we're done.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   433
        _next_survivor = NULL;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   434
      } else {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   435
        _next_survivor = res->get_next_young_region();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   436
      }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   437
    } else {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   438
      // Someone else claimed the last survivor while we were trying
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   439
      // to take the lock so nothing else to do.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   440
    }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   441
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   442
  assert(res == NULL || res->is_survivor(), "post-condition");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   443
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   444
  return res;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   445
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   446
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   447
void CMRootRegions::scan_finished() {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   448
  assert(scan_in_progress(), "pre-condition");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   449
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   450
  // Currently, only survivors can be root regions.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   451
  if (!_should_abort) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   452
    assert(_next_survivor == NULL, "we should have claimed all survivors");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   453
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   454
  _next_survivor = NULL;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   455
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   456
  {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   457
    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   458
    _scan_in_progress = false;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   459
    RootRegionScan_lock->notify_all();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   460
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   461
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   462
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   463
bool CMRootRegions::wait_until_scan_finished() {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   464
  if (!scan_in_progress()) return false;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   465
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   466
  {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   467
    MutexLockerEx x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   468
    while (scan_in_progress()) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   469
      RootRegionScan_lock->wait(Mutex::_no_safepoint_check_flag);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   470
    }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   471
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   472
  return true;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   473
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   474
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   475
#ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   476
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   477
#endif // _MSC_VER
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   478
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
   479
uint ConcurrentMark::scale_parallel_threads(uint n_par_threads) {
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
   480
  return MAX2((n_par_threads + 2) / 4, 1U);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   481
}
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   482
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   483
ConcurrentMark::ConcurrentMark(G1CollectedHeap* g1h, ReservedSpace heap_rs) :
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   484
  _g1h(g1h),
19982
f1adc8069935 8021823: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
tschatzl
parents: 19339
diff changeset
   485
  _markBitMap1(log2_intptr(MinObjAlignment)),
f1adc8069935 8021823: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
tschatzl
parents: 19339
diff changeset
   486
  _markBitMap2(log2_intptr(MinObjAlignment)),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   487
  _parallel_marking_threads(0),
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   488
  _max_parallel_marking_threads(0),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   489
  _sleep_factor(0.0),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   490
  _marking_task_overhead(1.0),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   491
  _cleanup_sleep_factor(0.0),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   492
  _cleanup_task_overhead(1.0),
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
   493
  _cleanup_list("Cleanup List"),
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   494
  _region_bm((BitMap::idx_t)(g1h->max_regions()), false /* in_resource_area*/),
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   495
  _card_bm((heap_rs.size() + CardTableModRefBS::card_size - 1) >>
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   496
            CardTableModRefBS::card_shift,
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   497
            false /* in_resource_area*/),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   498
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   499
  _prevMarkBitMap(&_markBitMap1),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   500
  _nextMarkBitMap(&_markBitMap2),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   501
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   502
  _markStack(this),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   503
  // _finger set in set_non_marking_state
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   504
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   505
  _max_worker_id(MAX2((uint)ParallelGCThreads, 1U)),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   506
  // _active_tasks set in set_non_marking_state
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   507
  // _tasks set inside the constructor
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   508
  _task_queues(new CMTaskQueueSet((int) _max_worker_id)),
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   509
  _terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   510
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   511
  _has_overflown(false),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   512
  _concurrent(false),
2145
da1dfec15623 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 1623
diff changeset
   513
  _has_aborted(false),
da1dfec15623 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 1623
diff changeset
   514
  _restart_for_overflow(false),
da1dfec15623 6814467: G1: small fixes related to concurrent marking verboseness
tonyp
parents: 1623
diff changeset
   515
  _concurrent_marking_in_progress(false),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   516
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   517
  // _verbose_level set below
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   518
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   519
  _init_times(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   520
  _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   521
  _cleanup_times(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   522
  _total_counting_time(0.0),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   523
  _total_rs_scrub_time(0.0),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   524
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   525
  _parallel_workers(NULL),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   526
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   527
  _count_card_bitmaps(NULL),
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   528
  _count_marked_bytes(NULL),
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   529
  _completed_initialization(false) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   530
  CMVerboseLevel verbose_level = (CMVerboseLevel) G1MarkingVerboseLevel;
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   531
  if (verbose_level < no_verbose) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   532
    verbose_level = no_verbose;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   533
  }
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   534
  if (verbose_level > high_verbose) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   535
    verbose_level = high_verbose;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   536
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   537
  _verbose_level = verbose_level;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   538
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   539
  if (verbose_low()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   540
    gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
   541
                           "heap end = " PTR_FORMAT, p2i(_heap_start), p2i(_heap_end));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   542
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   543
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   544
  if (!_markBitMap1.allocate(heap_rs)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   545
    warning("Failed to allocate first CM bit map");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   546
    return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   547
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   548
  if (!_markBitMap2.allocate(heap_rs)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   549
    warning("Failed to allocate second CM bit map");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   550
    return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   551
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   552
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   553
  // Create & start a ConcurrentMark thread.
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
   554
  _cmThread = new ConcurrentMarkThread(this);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
   555
  assert(cmThread() != NULL, "CM Thread should have been created");
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
   556
  assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
22220
eb467dfb9585 8029326: G1 does not check if threads gets created
ehelin
parents: 20282
diff changeset
   557
  if (_cmThread->osthread() == NULL) {
eb467dfb9585 8029326: G1 does not check if threads gets created
ehelin
parents: 20282
diff changeset
   558
      vm_shutdown_during_initialization("Could not create ConcurrentMarkThread");
eb467dfb9585 8029326: G1 does not check if threads gets created
ehelin
parents: 20282
diff changeset
   559
  }
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
   560
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   561
  assert(CGC_lock != NULL, "Where's the CGC_lock?");
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   562
  assert(_markBitMap1.covers(heap_rs), "_markBitMap1 inconsistency");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   563
  assert(_markBitMap2.covers(heap_rs), "_markBitMap2 inconsistency");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   564
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   565
  SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
5033
55f476a32544 6928059: G1: command line parameter renaming
tonyp
parents: 4481
diff changeset
   566
  satb_qs.set_buffer_size(G1SATBBufferSize);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   567
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   568
  _root_regions.init(_g1h, this);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   569
5035
0e498c4df637 6928081: G1: rename parameters common with CMS
jmasa
parents: 5033
diff changeset
   570
  if (ConcGCThreads > ParallelGCThreads) {
23858
dae377f5a7c7 8039244: Don't use UINT32_FORMAT and INT32_FORMAT when printing uints and ints in the GC code
stefank
parents: 23857
diff changeset
   571
    warning("Can't have more ConcGCThreads (" UINTX_FORMAT ") "
dae377f5a7c7 8039244: Don't use UINT32_FORMAT and INT32_FORMAT when printing uints and ints in the GC code
stefank
parents: 23857
diff changeset
   572
            "than ParallelGCThreads (" UINTX_FORMAT ").",
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   573
            ConcGCThreads, ParallelGCThreads);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   574
    return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   575
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   576
  if (ParallelGCThreads == 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   577
    // if we are not running with any parallel GC threads we will not
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   578
    // spawn any marking threads either
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   579
    _parallel_marking_threads =       0;
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   580
    _max_parallel_marking_threads =   0;
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   581
    _sleep_factor             =     0.0;
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
   582
    _marking_task_overhead    =     1.0;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   583
  } else {
15487
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   584
    if (!FLAG_IS_DEFAULT(ConcGCThreads) && ConcGCThreads > 0) {
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   585
      // Note: ConcGCThreads has precedence over G1MarkingOverheadPercent
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   586
      // if both are set
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   587
      _sleep_factor             = 0.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   588
      _marking_task_overhead    = 1.0;
2741
34e2a243d69a 6490395: G1: Tidy up command line flags.
johnc
parents: 2259
diff changeset
   589
    } else if (G1MarkingOverheadPercent > 0) {
15487
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   590
      // We will calculate the number of parallel marking threads based
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   591
      // on a target overhead with respect to the soft real-time goal
2741
34e2a243d69a 6490395: G1: Tidy up command line flags.
johnc
parents: 2259
diff changeset
   592
      double marking_overhead = (double) G1MarkingOverheadPercent / 100.0;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   593
      double overall_cm_overhead =
2741
34e2a243d69a 6490395: G1: Tidy up command line flags.
johnc
parents: 2259
diff changeset
   594
        (double) MaxGCPauseMillis * marking_overhead /
34e2a243d69a 6490395: G1: Tidy up command line flags.
johnc
parents: 2259
diff changeset
   595
        (double) GCPauseIntervalMillis;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   596
      double cpu_ratio = 1.0 / (double) os::processor_count();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   597
      double marking_thread_num = ceil(overall_cm_overhead / cpu_ratio);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   598
      double marking_task_overhead =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   599
        overall_cm_overhead / marking_thread_num *
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   600
                                                (double) os::processor_count();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   601
      double sleep_factor =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   602
                         (1.0 - marking_task_overhead) / marking_task_overhead;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   603
15487
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   604
      FLAG_SET_ERGO(uintx, ConcGCThreads, (uint) marking_thread_num);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   605
      _sleep_factor             = sleep_factor;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   606
      _marking_task_overhead    = marking_task_overhead;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   607
    } else {
15487
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   608
      // Calculate the number of parallel marking threads by scaling
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   609
      // the number of parallel GC threads.
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   610
      uint marking_thread_num = scale_parallel_threads((uint) ParallelGCThreads);
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   611
      FLAG_SET_ERGO(uintx, ConcGCThreads, marking_thread_num);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   612
      _sleep_factor             = 0.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   613
      _marking_task_overhead    = 1.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   614
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   615
15487
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   616
    assert(ConcGCThreads > 0, "Should have been set");
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   617
    _parallel_marking_threads = (uint) ConcGCThreads;
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   618
    _max_parallel_marking_threads = _parallel_marking_threads;
368fcc327963 8006894: G1: Number of marking threads missing from PrintFlagsFinal output
johnc
parents: 15090
diff changeset
   619
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   620
    if (parallel_marking_threads() > 1) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   621
      _cleanup_task_overhead = 1.0;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   622
    } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   623
      _cleanup_task_overhead = marking_task_overhead();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   624
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   625
    _cleanup_sleep_factor =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   626
                     (1.0 - cleanup_task_overhead()) / cleanup_task_overhead();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   627
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   628
#if 0
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   629
    gclog_or_tty->print_cr("Marking Threads          %d", parallel_marking_threads());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   630
    gclog_or_tty->print_cr("CM Marking Task Overhead %1.4lf", marking_task_overhead());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   631
    gclog_or_tty->print_cr("CM Sleep Factor          %1.4lf", sleep_factor());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   632
    gclog_or_tty->print_cr("CL Marking Task Overhead %1.4lf", cleanup_task_overhead());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   633
    gclog_or_tty->print_cr("CL Sleep Factor          %1.4lf", cleanup_sleep_factor());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   634
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   635
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   636
    guarantee(parallel_marking_threads() > 0, "peace of mind");
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
   637
    _parallel_workers = new FlexibleWorkGang("G1 Parallel Marking Threads",
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
   638
         _max_parallel_marking_threads, false, true);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
   639
    if (_parallel_workers == NULL) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   640
      vm_exit_during_initialization("Failed necessary allocation.");
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
   641
    } else {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
   642
      _parallel_workers->initialize_workers();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
   643
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   644
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   645
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   646
  if (FLAG_IS_DEFAULT(MarkStackSize)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   647
    uintx mark_stack_size =
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   648
      MIN2(MarkStackSizeMax,
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   649
          MAX2(MarkStackSize, (uintx) (parallel_marking_threads() * TASKQUEUE_SIZE)));
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   650
    // Verify that the calculated value for MarkStackSize is in range.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   651
    // It would be nice to use the private utility routine from Arguments.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   652
    if (!(mark_stack_size >= 1 && mark_stack_size <= MarkStackSizeMax)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   653
      warning("Invalid value calculated for MarkStackSize (" UINTX_FORMAT "): "
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   654
              "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
   655
              mark_stack_size, (uintx) 1, MarkStackSizeMax);
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   656
      return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   657
    }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   658
    FLAG_SET_ERGO(uintx, MarkStackSize, mark_stack_size);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   659
  } else {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   660
    // Verify MarkStackSize is in range.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   661
    if (FLAG_IS_CMDLINE(MarkStackSize)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   662
      if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   663
        if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   664
          warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT "): "
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   665
                  "must be between " UINTX_FORMAT " and " UINTX_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
   666
                  MarkStackSize, (uintx) 1, MarkStackSizeMax);
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   667
          return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   668
        }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   669
      } else if (FLAG_IS_CMDLINE(MarkStackSizeMax)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   670
        if (!(MarkStackSize >= 1 && MarkStackSize <= MarkStackSizeMax)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   671
          warning("Invalid value specified for MarkStackSize (" UINTX_FORMAT ")"
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   672
                  " or for MarkStackSizeMax (" UINTX_FORMAT ")",
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   673
                  MarkStackSize, MarkStackSizeMax);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   674
          return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   675
        }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   676
      }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   677
    }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   678
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   679
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   680
  if (!_markStack.allocate(MarkStackSize)) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   681
    warning("Failed to allocate CM marking stack");
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   682
    return;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   683
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   684
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   685
  _tasks = NEW_C_HEAP_ARRAY(CMTask*, _max_worker_id, mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   686
  _accum_task_vtime = NEW_C_HEAP_ARRAY(double, _max_worker_id, mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   687
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   688
  _count_card_bitmaps = NEW_C_HEAP_ARRAY(BitMap,  _max_worker_id, mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   689
  _count_marked_bytes = NEW_C_HEAP_ARRAY(size_t*, _max_worker_id, mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   690
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   691
  BitMap::idx_t card_bm_size = _card_bm.size();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   692
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   693
  // so that the assertion in MarkingTaskQueue::task_queue doesn't fail
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   694
  _active_tasks = _max_worker_id;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   695
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   696
  size_t max_regions = (size_t) _g1h->max_regions();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   697
  for (uint i = 0; i < _max_worker_id; ++i) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   698
    CMTaskQueue* task_queue = new CMTaskQueue();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   699
    task_queue->initialize();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   700
    _task_queues->register_queue(i, task_queue);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   701
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   702
    _count_card_bitmaps[i] = BitMap(card_bm_size, false);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   703
    _count_marked_bytes[i] = NEW_C_HEAP_ARRAY(size_t, max_regions, mtGC);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   704
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   705
    _tasks[i] = new CMTask(i, this,
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   706
                           _count_marked_bytes[i],
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   707
                           &_count_card_bitmaps[i],
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   708
                           task_queue, _task_queues);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   709
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   710
    _accum_task_vtime[i] = 0.0;
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   711
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   712
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   713
  // Calculate the card number for the bottom of the heap. Used
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   714
  // in biasing indexes into the accounting card bitmaps.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   715
  _heap_bottom_card_num =
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   716
    intptr_t(uintptr_t(_g1h->reserved_region().start()) >>
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   717
                                CardTableModRefBS::card_shift);
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   718
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   719
  // Clear all the liveness counting data
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   720
  clear_all_count_data();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   721
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   722
  // so that the call below can read a sensible value
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   723
  _heap_start = (HeapWord*) heap_rs.base();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   724
  set_non_marking_state();
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
   725
  _completed_initialization = true;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   726
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   727
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   728
void ConcurrentMark::update_g1_committed(bool force) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   729
  // If concurrent marking is not in progress, then we do not need to
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
   730
  // update _heap_end.
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   731
  if (!concurrent_marking_in_progress() && !force) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   732
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   733
  MemRegion committed = _g1h->g1_committed();
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   734
  assert(committed.start() == _heap_start, "start shouldn't change");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   735
  HeapWord* new_end = committed.end();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   736
  if (new_end > _heap_end) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   737
    // The heap has been expanded.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   738
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   739
    _heap_end = new_end;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   740
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   741
  // Notice that the heap can also shrink. However, this only happens
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   742
  // during a Full GC (at least currently) and the entire marking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   743
  // phase will bail out and the task will not be restarted. So, let's
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   744
  // do nothing.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   745
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   746
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   747
void ConcurrentMark::reset() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   748
  // Starting values for these two. This should be called in a STW
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   749
  // phase. CM will be notified of any future g1_committed expansions
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   750
  // will be at the end of evacuation pauses, when tasks are
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   751
  // inactive.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   752
  MemRegion committed = _g1h->g1_committed();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   753
  _heap_start = committed.start();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   754
  _heap_end   = committed.end();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   755
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   756
  // Separated the asserts so that we know which one fires.
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   757
  assert(_heap_start != NULL, "heap bounds should look ok");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   758
  assert(_heap_end != NULL, "heap bounds should look ok");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   759
  assert(_heap_start < _heap_end, "heap bounds should look ok");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   760
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   761
  // Reset all the marking data structures and any necessary flags
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   762
  reset_marking_state();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   763
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   764
  if (verbose_low()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   765
    gclog_or_tty->print_cr("[global] resetting");
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   766
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   767
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   768
  // We do reset all of them, since different phases will use
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   769
  // different number of active threads. So, it's easiest to have all
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   770
  // of them ready.
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   771
  for (uint i = 0; i < _max_worker_id; ++i) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   772
    _tasks[i]->reset(_nextMarkBitMap);
6761
f9191297ce83 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 6759
diff changeset
   773
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   774
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   775
  // we need this to make sure that the flag is on during the evac
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   776
  // pause with initial mark piggy-backed
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   777
  set_concurrent_marking_in_progress();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   778
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   779
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   780
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   781
void ConcurrentMark::reset_marking_state(bool clear_overflow) {
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   782
  _markStack.set_should_expand();
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   783
  _markStack.setEmpty();        // Also clears the _markStack overflow flag
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   784
  if (clear_overflow) {
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   785
    clear_has_overflown();
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   786
  } else {
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   787
    assert(has_overflown(), "pre-condition");
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   788
  }
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   789
  _finger = _heap_start;
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   790
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   791
  for (uint i = 0; i < _max_worker_id; ++i) {
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   792
    CMTaskQueue* queue = _task_queues->queue(i);
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   793
    queue->set_empty();
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   794
  }
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   795
}
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   796
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   797
void ConcurrentMark::set_concurrency(uint active_tasks) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   798
  assert(active_tasks <= _max_worker_id, "we should not have more");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   799
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   800
  _active_tasks = active_tasks;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   801
  // Need to update the three data structures below according to the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   802
  // number of active threads for this phase.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   803
  _terminator   = ParallelTaskTerminator((int) active_tasks, _task_queues);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   804
  _first_overflow_barrier_sync.set_n_workers((int) active_tasks);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   805
  _second_overflow_barrier_sync.set_n_workers((int) active_tasks);
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   806
}
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   807
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   808
void ConcurrentMark::set_concurrency_and_phase(uint active_tasks, bool concurrent) {
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   809
  set_concurrency(active_tasks);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   810
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   811
  _concurrent = concurrent;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   812
  // We propagate this to all tasks, not just the active ones.
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   813
  for (uint i = 0; i < _max_worker_id; ++i)
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   814
    _tasks[i]->set_concurrent(concurrent);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   815
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   816
  if (concurrent) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   817
    set_concurrent_marking_in_progress();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   818
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   819
    // We currently assume that the concurrent flag has been set to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   820
    // false before we start remark. At this point we should also be
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   821
    // in a STW phase.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
   822
    assert(!concurrent_marking_in_progress(), "invariant");
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   823
    assert(_finger == _heap_end,
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   824
           err_msg("only way to get here: _finger: "PTR_FORMAT", _heap_end: "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
   825
                   p2i(_finger), p2i(_heap_end)));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   826
    update_g1_committed(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   827
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   828
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   829
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   830
void ConcurrentMark::set_non_marking_state() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   831
  // We set the global marking state to some default values when we're
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   832
  // not doing marking.
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
   833
  reset_marking_state();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   834
  _active_tasks = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   835
  clear_concurrent_marking_in_progress();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   836
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   837
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   838
ConcurrentMark::~ConcurrentMark() {
11403
2a7f52ac7ce3 7125516: G1: ~ConcurrentMark() frees incorrectly
stefank
parents: 11396
diff changeset
   839
  // The ConcurrentMark instance is never freed.
2a7f52ac7ce3 7125516: G1: ~ConcurrentMark() frees incorrectly
stefank
parents: 11396
diff changeset
   840
  ShouldNotReachHere();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   841
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   842
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   843
void ConcurrentMark::clearNextBitmap() {
5243
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   844
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   845
  G1CollectorPolicy* g1p = g1h->g1_policy();
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   846
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   847
  // Make sure that the concurrent mark thread looks to still be in
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   848
  // the current cycle.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   849
  guarantee(cmThread()->during_cycle(), "invariant");
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   850
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   851
  // We are finishing up the current cycle by clearing the next
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   852
  // marking bitmap and getting it ready for the next cycle. During
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   853
  // this time no other cycle can start. So, let's make sure that this
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   854
  // is the case.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   855
  guarantee(!g1h->mark_in_progress(), "invariant");
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   856
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   857
  // clear the mark bitmap (no grey objects to start with).
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   858
  // We need to do this in chunks and offer to yield in between
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   859
  // each chunk.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   860
  HeapWord* start  = _nextMarkBitMap->startWord();
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   861
  HeapWord* end    = _nextMarkBitMap->endWord();
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   862
  HeapWord* cur    = start;
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   863
  size_t chunkSize = M;
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   864
  while (cur < end) {
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   865
    HeapWord* next = cur + chunkSize;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   866
    if (next > end) {
5243
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   867
      next = end;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   868
    }
5243
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   869
    MemRegion mr(cur,next);
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   870
    _nextMarkBitMap->clearRange(mr);
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   871
    cur = next;
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   872
    do_yield_check();
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   873
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   874
    // Repeat the asserts from above. We'll do them as asserts here to
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   875
    // minimize their overhead on the product. However, we'll have
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   876
    // them as guarantees at the beginning / end of the bitmap
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   877
    // clearing to get some checking in the product.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   878
    assert(cmThread()->during_cycle(), "invariant");
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   879
    assert(!g1h->mark_in_progress(), "invariant");
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   880
  }
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   881
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   882
  // Clear the liveness counting data
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   883
  clear_all_count_data();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
   884
5243
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   885
  // Repeat the asserts from above.
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   886
  guarantee(cmThread()->during_cycle(), "invariant");
99e5a8f5d81f 6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents: 5242
diff changeset
   887
  guarantee(!g1h->mark_in_progress(), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   888
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   889
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   890
class NoteStartOfMarkHRClosure: public HeapRegionClosure {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   891
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   892
  bool doHeapRegion(HeapRegion* r) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   893
    if (!r->continuesHumongous()) {
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   894
      r->note_start_of_marking();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   895
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   896
    return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   897
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   898
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   899
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   900
void ConcurrentMark::checkpointRootsInitialPre() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   901
  G1CollectedHeap*   g1h = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   902
  G1CollectorPolicy* g1p = g1h->g1_policy();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   903
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   904
  _has_aborted = false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   905
5542
be05c5ffe905 6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents: 5344
diff changeset
   906
#ifndef PRODUCT
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
   907
  if (G1PrintReachableAtInitialMark) {
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
   908
    print_reachable("at-cycle-start",
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
   909
                    VerifyOption_G1UsePrevMarking, true /* all */);
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
   910
  }
5542
be05c5ffe905 6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents: 5344
diff changeset
   911
#endif
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   912
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
   913
  // Initialize marking structures. This has to be done in a STW phase.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   914
  reset();
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   915
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   916
  // For each region note start of marking.
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   917
  NoteStartOfMarkHRClosure startcl;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
   918
  g1h->heap_region_iterate(&startcl);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   919
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   920
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   921
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   922
void ConcurrentMark::checkpointRootsInitialPost() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   923
  G1CollectedHeap*   g1h = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   924
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   925
  // If we force an overflow during remark, the remark operation will
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   926
  // actually abort and we'll restart concurrent marking. If we always
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
   927
  // force an overflow during remark we'll never actually complete the
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
   928
  // marking phase. So, we initialize this here, at the start of the
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   929
  // cycle, so that at the remaining overflow number will decrease at
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   930
  // every remark and we'll eventually not need to cause one.
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   931
  force_overflow_stw()->init();
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   932
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
   933
  // Start Concurrent Marking weak-reference discovery.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
   934
  ReferenceProcessor* rp = g1h->ref_processor_cm();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
   935
  // enable ("weak") refs discovery
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
   936
  rp->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/);
1610
5dddd195cc86 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 1606
diff changeset
   937
  rp->setup_policy(false); // snapshot the soft ref policy to be used in this cycle
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   938
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   939
  SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
5082
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
   940
  // This is the start of  the marking cycle, we're expected all
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
   941
  // threads to have SATB queues with active set to false.
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
   942
  satb_mq_set.set_active_all_threads(true, /* new active value */
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
   943
                                     false /* expected_active */);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   944
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   945
  _root_regions.prepare_for_scan();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
   946
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   947
  // update_g1_committed() will be called at the end of an evac pause
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   948
  // when marking is on. So, it's also called at the end of the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   949
  // initial-mark pause to update the heap end, if the heap expands
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   950
  // during it. No need to call it here.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   951
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   952
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   953
/*
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   954
 * Notice that in the next two methods, we actually leave the STS
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   955
 * during the barrier sync and join it immediately afterwards. If we
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   956
 * do not do this, the following deadlock can occur: one thread could
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   957
 * be in the barrier sync code, waiting for the other thread to also
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   958
 * sync up, whereas another one could be trying to yield, while also
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   959
 * waiting for the other threads to sync up too.
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   960
 *
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   961
 * Note, however, that this code is also used during remark and in
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   962
 * this case we should not attempt to leave / enter the STS, otherwise
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
   963
 * we'll either hit an assert (debug / fastdebug) or deadlock
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   964
 * (product). So we should only leave / enter the STS if we are
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   965
 * operating concurrently.
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   966
 *
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   967
 * Because the thread that does the sync barrier has left the STS, it
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   968
 * is possible to be suspended for a Full GC or an evacuation pause
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   969
 * could occur. This is actually safe, since the entering the sync
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   970
 * barrier is one of the last things do_marking_step() does, and it
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   971
 * doesn't manipulate any data structures afterwards.
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   972
 */
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   973
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   974
void ConcurrentMark::enter_first_sync_barrier(uint worker_id) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   975
  if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   976
    gclog_or_tty->print_cr("[%u] entering first barrier", worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   977
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   978
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   979
  if (concurrent()) {
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
   980
    SuspendibleThreadSet::leave();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   981
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   982
  _first_overflow_barrier_sync.enter();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   983
  if (concurrent()) {
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
   984
    SuspendibleThreadSet::join();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
   985
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   986
  // at this point everyone should have synced up and not be doing any
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   987
  // more work
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   988
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   989
  if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
   990
    gclog_or_tty->print_cr("[%u] leaving first barrier", worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
   991
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
   992
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   993
  // If we're executing the concurrent phase of marking, reset the marking
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   994
  // state; otherwise the marking state is reset after reference processing,
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   995
  // during the remark pause.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   996
  // If we reset here as a result of an overflow during the remark we will
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   997
  // see assertion failures from any subsequent set_concurrency_and_phase()
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   998
  // calls.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
   999
  if (concurrent()) {
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1000
    // let the task associated with with worker 0 do this
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1001
    if (worker_id == 0) {
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1002
      // task 0 is responsible for clearing the global data structures
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1003
      // We should be here because of an overflow. During STW we should
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1004
      // not clear the overflow flag since we rely on it being true when
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  1005
      // we exit this method to abort the pause and restart concurrent
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1006
      // marking.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1007
      reset_marking_state(true /* clear_overflow */);
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1008
      force_overflow()->update();
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1009
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1010
      if (G1Log::fine()) {
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1011
        gclog_or_tty->date_stamp(PrintGCDateStamps);
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1012
        gclog_or_tty->stamp(PrintGCTimeStamps);
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1013
        gclog_or_tty->print_cr("[GC concurrent-mark-reset-for-overflow]");
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1014
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1015
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1016
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1017
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1018
  // after this, each task should reset its own data structures then
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1019
  // then go into the second barrier
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1020
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1021
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  1022
void ConcurrentMark::enter_second_sync_barrier(uint worker_id) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1023
  if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  1024
    gclog_or_tty->print_cr("[%u] entering second barrier", worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1025
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1026
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1027
  if (concurrent()) {
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1028
    SuspendibleThreadSet::leave();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1029
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1030
  _second_overflow_barrier_sync.enter();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1031
  if (concurrent()) {
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1032
    SuspendibleThreadSet::join();
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1033
  }
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1034
  // at this point everything should be re-initialized and ready to go
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1035
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1036
  if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  1037
    gclog_or_tty->print_cr("[%u] leaving second barrier", worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1038
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1039
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1040
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1041
#ifndef PRODUCT
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1042
void ForceOverflowSettings::init() {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1043
  _num_remaining = G1ConcMarkForceOverflow;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1044
  _force = false;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1045
  update();
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1046
}
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1047
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1048
void ForceOverflowSettings::update() {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1049
  if (_num_remaining > 0) {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1050
    _num_remaining -= 1;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1051
    _force = true;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1052
  } else {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1053
    _force = false;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1054
  }
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1055
}
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1056
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1057
bool ForceOverflowSettings::should_force() {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1058
  if (_force) {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1059
    _force = false;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1060
    return true;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1061
  } else {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1062
    return false;
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1063
  }
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1064
}
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1065
#endif // !PRODUCT
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1066
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1067
class CMConcurrentMarkingTask: public AbstractGangTask {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1068
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1069
  ConcurrentMark*       _cm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1070
  ConcurrentMarkThread* _cmt;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1071
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1072
public:
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1073
  void work(uint worker_id) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  1074
    assert(Thread::current()->is_ConcurrentGC_thread(),
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  1075
           "this should only be done by a conc GC thread");
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1076
    ResourceMark rm;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1077
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1078
    double start_vtime = os::elapsedVTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1079
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1080
    SuspendibleThreadSet::join();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1081
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1082
    assert(worker_id < _cm->active_tasks(), "invariant");
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1083
    CMTask* the_task = _cm->task(worker_id);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1084
    the_task->record_start_time();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1085
    if (!_cm->has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1086
      do {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1087
        double start_vtime_sec = os::elapsedVTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1088
        double start_time_sec = os::elapsedTime();
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1089
        double mark_step_duration_ms = G1ConcMarkStepDurationMillis;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1090
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1091
        the_task->do_marking_step(mark_step_duration_ms,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  1092
                                  true  /* do_termination */,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  1093
                                  false /* is_serial*/);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1094
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1095
        double end_time_sec = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1096
        double end_vtime_sec = os::elapsedVTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1097
        double elapsed_vtime_sec = end_vtime_sec - start_vtime_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1098
        double elapsed_time_sec = end_time_sec - start_time_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1099
        _cm->clear_has_overflown();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1100
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1101
        bool ret = _cm->do_yield_check(worker_id);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1102
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1103
        jlong sleep_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1104
        if (!_cm->has_aborted() && the_task->has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1105
          sleep_time_ms =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1106
            (jlong) (elapsed_vtime_sec * _cm->sleep_factor() * 1000.0);
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1107
          SuspendibleThreadSet::leave();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1108
          os::sleep(Thread::current(), sleep_time_ms, false);
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1109
          SuspendibleThreadSet::join();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1110
        }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1111
        double end_time2_sec = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1112
        double elapsed_time2_sec = end_time2_sec - start_time_sec;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1113
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1114
#if 0
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1115
          gclog_or_tty->print_cr("CM: elapsed %1.4lf ms, sleep %1.4lf ms, "
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1116
                                 "overhead %1.4lf",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1117
                                 elapsed_vtime_sec * 1000.0, (double) sleep_time_ms,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1118
                                 the_task->conc_overhead(os::elapsedTime()) * 8.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1119
          gclog_or_tty->print_cr("elapsed time %1.4lf ms, time 2: %1.4lf ms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1120
                                 elapsed_time_sec * 1000.0, elapsed_time2_sec * 1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1121
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1122
      } while (!_cm->has_aborted() && the_task->has_aborted());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1123
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1124
    the_task->record_end_time();
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  1125
    guarantee(!the_task->has_aborted() || _cm->has_aborted(), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1126
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  1127
    SuspendibleThreadSet::leave();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1128
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1129
    double end_vtime = os::elapsedVTime();
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1130
    _cm->update_accum_task_vtime(worker_id, end_vtime - start_vtime);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1131
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1132
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1133
  CMConcurrentMarkingTask(ConcurrentMark* cm,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1134
                          ConcurrentMarkThread* cmt) :
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1135
      AbstractGangTask("Concurrent Mark"), _cm(cm), _cmt(cmt) { }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1136
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1137
  ~CMConcurrentMarkingTask() { }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1138
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1139
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1140
// Calculates the number of active workers for a concurrent
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1141
// phase.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1142
uint ConcurrentMark::calc_parallel_marking_threads() {
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1143
  if (G1CollectedHeap::use_parallel_gc_threads()) {
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1144
    uint n_conc_workers = 0;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1145
    if (!UseDynamicNumberOfGCThreads ||
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1146
        (!FLAG_IS_DEFAULT(ConcGCThreads) &&
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1147
         !ForceDynamicNumberOfGCThreads)) {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1148
      n_conc_workers = max_parallel_marking_threads();
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1149
    } else {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1150
      n_conc_workers =
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1151
        AdaptiveSizePolicy::calc_default_active_workers(
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1152
                                     max_parallel_marking_threads(),
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1153
                                     1, /* Minimum workers */
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1154
                                     parallel_marking_threads(),
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1155
                                     Threads::number_of_non_daemon_threads());
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1156
      // Don't scale down "n_conc_workers" by scale_parallel_threads() because
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1157
      // that scaling has already gone into "_max_parallel_marking_threads".
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1158
    }
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1159
    assert(n_conc_workers > 0, "Always need at least 1");
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1160
    return n_conc_workers;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1161
  }
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1162
  // If we are not running with any parallel GC threads we will not
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1163
  // have spawned any marking threads either. Hence the number of
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1164
  // concurrent workers should be 0.
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1165
  return 0;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1166
}
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1167
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1168
void ConcurrentMark::scanRootRegion(HeapRegion* hr, uint worker_id) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1169
  // Currently, only survivors can be root regions.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1170
  assert(hr->next_top_at_mark_start() == hr->bottom(), "invariant");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1171
  G1RootRegionScanClosure cl(_g1h, this, worker_id);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1172
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1173
  const uintx interval = PrefetchScanIntervalInBytes;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1174
  HeapWord* curr = hr->bottom();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1175
  const HeapWord* end = hr->top();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1176
  while (curr < end) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1177
    Prefetch::read(curr, interval);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1178
    oop obj = oop(curr);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1179
    int size = obj->oop_iterate(&cl);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1180
    assert(size == obj->size(), "sanity");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1181
    curr += size;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1182
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1183
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1184
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1185
class CMRootRegionScanTask : public AbstractGangTask {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1186
private:
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1187
  ConcurrentMark* _cm;
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1188
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1189
public:
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1190
  CMRootRegionScanTask(ConcurrentMark* cm) :
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1191
    AbstractGangTask("Root Region Scan"), _cm(cm) { }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1192
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1193
  void work(uint worker_id) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1194
    assert(Thread::current()->is_ConcurrentGC_thread(),
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1195
           "this should only be done by a conc GC thread");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1196
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1197
    CMRootRegions* root_regions = _cm->root_regions();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1198
    HeapRegion* hr = root_regions->claim_next();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1199
    while (hr != NULL) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1200
      _cm->scanRootRegion(hr, worker_id);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1201
      hr = root_regions->claim_next();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1202
    }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1203
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1204
};
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1205
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1206
void ConcurrentMark::scanRootRegions() {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1207
  // scan_in_progress() will have been set to true only if there was
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1208
  // at least one root region to scan. So, if it's false, we
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1209
  // should not attempt to do any further work.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1210
  if (root_regions()->scan_in_progress()) {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1211
    _parallel_marking_threads = calc_parallel_marking_threads();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1212
    assert(parallel_marking_threads() <= max_parallel_marking_threads(),
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1213
           "Maximum number of marking threads exceeded");
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1214
    uint active_workers = MAX2(1U, parallel_marking_threads());
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1215
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1216
    CMRootRegionScanTask task(this);
15489
0f2bd608c4f2 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 15487
diff changeset
  1217
    if (use_parallel_marking_threads()) {
11584
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1218
      _parallel_workers->set_active_workers((int) active_workers);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1219
      _parallel_workers->run_task(&task);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1220
    } else {
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1221
      task.work(0);
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1222
    }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1223
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1224
    // It's possible that has_aborted() is true here without actually
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1225
    // aborting the survivor scan earlier. This is OK as it's
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1226
    // mainly used for sanity checking.
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1227
    root_regions()->scan_finished();
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1228
  }
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1229
}
e1df4d08a1f4 7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents: 11583
diff changeset
  1230
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1231
void ConcurrentMark::markFromRoots() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1232
  // we might be tempted to assert that:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1233
  // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1234
  //        "inconsistent argument?");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1235
  // However that wouldn't be right, because it's possible that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1236
  // a safepoint is indeed in progress as a younger generation
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1237
  // stop-the-world GC happens even as we mark in this generation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1238
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1239
  _restart_for_overflow = false;
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  1240
  force_overflow_conc()->init();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1241
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1242
  // _g1h has _n_par_threads
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1243
  _parallel_marking_threads = calc_parallel_marking_threads();
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1244
  assert(parallel_marking_threads() <= max_parallel_marking_threads(),
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1245
    "Maximum number of marking threads exceeded");
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1246
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1247
  uint active_workers = MAX2(1U, parallel_marking_threads());
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1248
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1249
  // Parallel task terminator is set in "set_concurrency_and_phase()"
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  1250
  set_concurrency_and_phase(active_workers, true /* concurrent */);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1251
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1252
  CMConcurrentMarkingTask markingTask(this, cmThread());
15489
0f2bd608c4f2 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 15487
diff changeset
  1253
  if (use_parallel_marking_threads()) {
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1254
    _parallel_workers->set_active_workers((int)active_workers);
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  1255
    // Don't set _n_par_threads because it affects MT in process_strong_roots()
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1256
    // and the decisions on that MT processing is made elsewhere.
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  1257
    assert(_parallel_workers->active_workers() > 0, "Should have been set");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1258
    _parallel_workers->run_task(&markingTask);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1259
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1260
    markingTask.work(0);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1261
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1262
  print_stats();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1263
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1264
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1265
void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1266
  // world is stopped at this checkpoint
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1267
  assert(SafepointSynchronize::is_at_safepoint(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1268
         "world should be stopped");
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  1269
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1270
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1271
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1272
  // If a full collection has happened, we shouldn't do this.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1273
  if (has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1274
    g1h->set_marking_complete(); // So bitmap clearing isn't confused
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1275
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1276
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1277
7896
08aadd7aa3ee 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 7657
diff changeset
  1278
  SvcGCMarker sgcm(SvcGCMarker::OTHER);
08aadd7aa3ee 6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents: 7657
diff changeset
  1279
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1280
  if (VerifyDuringGC) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1281
    HandleMark hm;  // handle scope
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1282
    Universe::heap()->prepare_for_verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1283
    Universe::verify(VerifyOption_G1UsePrevMarking,
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1284
                     " VerifyDuringGC:(before)");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1285
  }
24244
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  1286
  g1h->check_bitmaps("Remark Start");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1287
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1288
  G1CollectorPolicy* g1p = g1h->g1_policy();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1289
  g1p->record_concurrent_mark_remark_start();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1290
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1291
  double start = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1292
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1293
  checkpointRootsFinalWork();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1294
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1295
  double mark_work_end = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1296
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1297
  weakRefsWork(clear_all_soft_refs);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1298
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1299
  if (has_overflown()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1300
    // Oops.  We overflowed.  Restart concurrent marking.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1301
    _restart_for_overflow = true;
16390
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1302
    if (G1TraceMarkStackOverflow) {
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1303
      gclog_or_tty->print_cr("\nRemark led to restart for overflow.");
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1304
    }
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1305
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1306
    // Verify the heap w.r.t. the previous marking bitmap.
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1307
    if (VerifyDuringGC) {
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1308
      HandleMark hm;  // handle scope
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1309
      Universe::heap()->prepare_for_verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1310
      Universe::verify(VerifyOption_G1UsePrevMarking,
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1311
                       " VerifyDuringGC:(overflow)");
16390
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1312
    }
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  1313
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  1314
    // Clear the marking state because we will be restarting
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  1315
    // marking due to overflowing the global mark stack.
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  1316
    reset_marking_state();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1317
  } else {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1318
    // Aggregate the per-task counting data that we have accumulated
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1319
    // while marking.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1320
    aggregate_count_data();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1321
7920
298df61588a2 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 7896
diff changeset
  1322
    SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1323
    // We're done with marking.
5082
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  1324
    // This is the end of  the marking cycle, we're expected all
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  1325
    // threads to have SATB queues with active set to true.
7920
298df61588a2 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 7896
diff changeset
  1326
    satb_mq_set.set_active_all_threads(false, /* new active value */
298df61588a2 7011379: G1: overly long concurrent marking cycles
tonyp
parents: 7896
diff changeset
  1327
                                       true /* expected_active */);
3000
bbce6052b595 6850846: G1: extend G1 marking verification
tonyp
parents: 2741
diff changeset
  1328
bbce6052b595 6850846: G1: extend G1 marking verification
tonyp
parents: 2741
diff changeset
  1329
    if (VerifyDuringGC) {
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1330
      HandleMark hm;  // handle scope
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1331
      Universe::heap()->prepare_for_verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1332
      Universe::verify(VerifyOption_G1UseNextMarking,
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1333
                       " VerifyDuringGC:(after)");
3000
bbce6052b595 6850846: G1: extend G1 marking verification
tonyp
parents: 2741
diff changeset
  1334
    }
24244
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  1335
    g1h->check_bitmaps("Remark End");
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1336
    assert(!restart_for_overflow(), "sanity");
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  1337
    // Completely reset the marking state since marking completed
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  1338
    set_non_marking_state();
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1339
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  1340
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  1341
  // Expand the marking stack, if we have to and if we can.
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  1342
  if (_markStack.should_expand()) {
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  1343
    _markStack.expand();
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  1344
  }
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  1345
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1346
  // Statistics
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1347
  double now = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1348
  _remark_mark_times.add((mark_work_end - start) * 1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1349
  _remark_weak_ref_times.add((now - mark_work_end) * 1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1350
  _remark_times.add((now - start) * 1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1351
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1352
  g1p->record_concurrent_mark_remark_end();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  1353
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  1354
  G1CMIsAliveClosure is_alive(g1h);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  1355
  g1h->gc_tracer_cm()->report_object_count_after_gc(&is_alive);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1356
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1357
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1358
// Base class of the closures that finalize and verify the
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1359
// liveness counting data.
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1360
class CMCountDataClosureBase: public HeapRegionClosure {
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1361
protected:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1362
  G1CollectedHeap* _g1h;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1363
  ConcurrentMark* _cm;
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1364
  CardTableModRefBS* _ct_bs;
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1365
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1366
  BitMap* _region_bm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1367
  BitMap* _card_bm;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1368
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1369
  // Takes a region that's not empty (i.e., it has at least one
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1370
  // live object in it and sets its corresponding bit on the region
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1371
  // bitmap to 1. If the region is "starts humongous" it will also set
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1372
  // to 1 the bits on the region bitmap that correspond to its
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1373
  // associated "continues humongous" regions.
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1374
  void set_bit_for_region(HeapRegion* hr) {
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1375
    assert(!hr->continuesHumongous(), "should have filtered those out");
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1376
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1377
    BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index();
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1378
    if (!hr->startsHumongous()) {
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1379
      // Normal (non-humongous) case: just set the bit.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1380
      _region_bm->par_at_put(index, true);
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1381
    } else {
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1382
      // Starts humongous case: calculate how many regions are part of
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1383
      // this humongous region and then set the bit range.
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1384
      BitMap::idx_t end_index = (BitMap::idx_t) hr->last_hc_index();
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1385
      _region_bm->par_at_put_range(index, end_index, true);
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1386
    }
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1387
  }
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1388
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1389
public:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1390
  CMCountDataClosureBase(G1CollectedHeap* g1h,
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1391
                         BitMap* region_bm, BitMap* card_bm):
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1392
    _g1h(g1h), _cm(g1h->concurrent_mark()),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1393
    _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1394
    _region_bm(region_bm), _card_bm(card_bm) { }
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1395
};
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1396
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1397
// Closure that calculates the # live objects per region. Used
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1398
// for verification purposes during the cleanup pause.
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1399
class CalcLiveObjectsClosure: public CMCountDataClosureBase {
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1400
  CMBitMapRO* _bm;
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1401
  size_t _region_marked_bytes;
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1402
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1403
public:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1404
  CalcLiveObjectsClosure(CMBitMapRO *bm, G1CollectedHeap* g1h,
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1405
                         BitMap* region_bm, BitMap* card_bm) :
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1406
    CMCountDataClosureBase(g1h, region_bm, card_bm),
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1407
    _bm(bm), _region_marked_bytes(0) { }
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1408
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1409
  bool doHeapRegion(HeapRegion* hr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1410
2251
25b1f510e1b2 6815683: G1: SEGV during marking
iveresov
parents: 2145
diff changeset
  1411
    if (hr->continuesHumongous()) {
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1412
      // We will ignore these here and process them when their
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1413
      // associated "starts humongous" region is processed (see
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1414
      // set_bit_for_heap_region()). Note that we cannot rely on their
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1415
      // associated "starts humongous" region to have their bit set to
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1416
      // 1 since, due to the region chunking in the parallel region
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1417
      // iteration, a "continues humongous" region might be visited
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1418
      // before its associated "starts humongous".
2251
25b1f510e1b2 6815683: G1: SEGV during marking
iveresov
parents: 2145
diff changeset
  1419
      return false;
25b1f510e1b2 6815683: G1: SEGV during marking
iveresov
parents: 2145
diff changeset
  1420
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1421
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1422
    HeapWord* ntams = hr->next_top_at_mark_start();
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1423
    HeapWord* start = hr->bottom();
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1424
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1425
    assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1426
           err_msg("Preconditions not met - "
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1427
                   "start: "PTR_FORMAT", ntams: "PTR_FORMAT", end: "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  1428
                   p2i(start), p2i(ntams), p2i(hr->end())));
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1429
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1430
    // Find the first marked object at or after "start".
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1431
    start = _bm->getNextMarkedWordAddress(start, ntams);
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1432
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1433
    size_t marked_bytes = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1434
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1435
    while (start < ntams) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1436
      oop obj = oop(start);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1437
      int obj_sz = obj->size();
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1438
      HeapWord* obj_end = start + obj_sz;
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1439
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1440
      BitMap::idx_t start_idx = _cm->card_bitmap_index_for(start);
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1441
      BitMap::idx_t end_idx = _cm->card_bitmap_index_for(obj_end);
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1442
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1443
      // Note: if we're looking at the last region in heap - obj_end
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1444
      // could be actually just beyond the end of the heap; end_idx
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1445
      // will then correspond to a (non-existent) card that is also
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1446
      // just beyond the heap.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1447
      if (_g1h->is_in_g1_reserved(obj_end) && !_ct_bs->is_card_aligned(obj_end)) {
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1448
        // end of object is not card aligned - increment to cover
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1449
        // all the cards spanned by the object
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1450
        end_idx += 1;
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1451
      }
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1452
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1453
      // Set the bits in the card BM for the cards spanned by this object.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1454
      _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1455
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1456
      // Add the size of this object to the number of marked bytes.
4033
b4c91a37edea 6858886: G1: guarantee(_next_marked_bytes <= used(),"invariant") at heapRegion.hpp:359
apetrusenko
parents: 4026
diff changeset
  1457
      marked_bytes += (size_t)obj_sz * HeapWordSize;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1458
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1459
      // Find the next marked object after this one.
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1460
      start = _bm->getNextMarkedWordAddress(obj_end, ntams);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1461
    }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1462
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1463
    // Mark the allocated-since-marking portion...
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1464
    HeapWord* top = hr->top();
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1465
    if (ntams < top) {
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1466
      BitMap::idx_t start_idx = _cm->card_bitmap_index_for(ntams);
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1467
      BitMap::idx_t end_idx = _cm->card_bitmap_index_for(top);
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1468
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1469
      // Note: if we're looking at the last region in heap - top
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1470
      // could be actually just beyond the end of the heap; end_idx
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1471
      // will then correspond to a (non-existent) card that is also
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1472
      // just beyond the heap.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1473
      if (_g1h->is_in_g1_reserved(top) && !_ct_bs->is_card_aligned(top)) {
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1474
        // end of object is not card aligned - increment to cover
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1475
        // all the cards spanned by the object
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1476
        end_idx += 1;
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1477
      }
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1478
      _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1479
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1480
      // This definitely means the region has live objects.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1481
      set_bit_for_region(hr);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1482
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1483
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1484
    // Update the live region bitmap.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1485
    if (marked_bytes > 0) {
3182
2ec0cb2496b8 6850869: G1: RSet "scrubbing" scrubs too much
tonyp
parents: 3000
diff changeset
  1486
      set_bit_for_region(hr);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1487
    }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1488
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1489
    // Set the marked bytes for the current region so that
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  1490
    // it can be queried by a calling verification routine
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1491
    _region_marked_bytes = marked_bytes;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1492
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1493
    return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1494
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1495
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1496
  size_t region_marked_bytes() const { return _region_marked_bytes; }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1497
};
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1498
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1499
// Heap region closure used for verifying the counting data
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1500
// that was accumulated concurrently and aggregated during
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1501
// the remark pause. This closure is applied to the heap
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1502
// regions during the STW cleanup pause.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1503
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1504
class VerifyLiveObjectDataHRClosure: public HeapRegionClosure {
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1505
  G1CollectedHeap* _g1h;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1506
  ConcurrentMark* _cm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1507
  CalcLiveObjectsClosure _calc_cl;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1508
  BitMap* _region_bm;   // Region BM to be verified
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1509
  BitMap* _card_bm;     // Card BM to be verified
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1510
  bool _verbose;        // verbose output?
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1511
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1512
  BitMap* _exp_region_bm; // Expected Region BM values
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1513
  BitMap* _exp_card_bm;   // Expected card BM values
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1514
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1515
  int _failures;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1516
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1517
public:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1518
  VerifyLiveObjectDataHRClosure(G1CollectedHeap* g1h,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1519
                                BitMap* region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1520
                                BitMap* card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1521
                                BitMap* exp_region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1522
                                BitMap* exp_card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1523
                                bool verbose) :
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1524
    _g1h(g1h), _cm(g1h->concurrent_mark()),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1525
    _calc_cl(_cm->nextMarkBitMap(), g1h, exp_region_bm, exp_card_bm),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1526
    _region_bm(region_bm), _card_bm(card_bm), _verbose(verbose),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1527
    _exp_region_bm(exp_region_bm), _exp_card_bm(exp_card_bm),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1528
    _failures(0) { }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1529
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1530
  int failures() const { return _failures; }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1531
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1532
  bool doHeapRegion(HeapRegion* hr) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1533
    if (hr->continuesHumongous()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1534
      // We will ignore these here and process them when their
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1535
      // associated "starts humongous" region is processed (see
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1536
      // set_bit_for_heap_region()). Note that we cannot rely on their
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1537
      // associated "starts humongous" region to have their bit set to
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1538
      // 1 since, due to the region chunking in the parallel region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1539
      // iteration, a "continues humongous" region might be visited
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1540
      // before its associated "starts humongous".
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1541
      return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1542
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1543
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1544
    int failures = 0;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1545
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1546
    // Call the CalcLiveObjectsClosure to walk the marking bitmap for
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1547
    // this region and set the corresponding bits in the expected region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1548
    // and card bitmaps.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1549
    bool res = _calc_cl.doHeapRegion(hr);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1550
    assert(res == false, "should be continuing");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1551
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1552
    MutexLockerEx x((_verbose ? ParGCRareEvent_lock : NULL),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1553
                    Mutex::_no_safepoint_check_flag);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1554
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1555
    // Verify the marked bytes for this region.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1556
    size_t exp_marked_bytes = _calc_cl.region_marked_bytes();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1557
    size_t act_marked_bytes = hr->next_marked_bytes();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1558
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1559
    // We're not OK if expected marked bytes > actual marked bytes. It means
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1560
    // we have missed accounting some objects during the actual marking.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1561
    if (exp_marked_bytes > act_marked_bytes) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1562
      if (_verbose) {
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1563
        gclog_or_tty->print_cr("Region %u: marked bytes mismatch: "
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1564
                               "expected: " SIZE_FORMAT ", actual: " SIZE_FORMAT,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1565
                               hr->hrs_index(), exp_marked_bytes, act_marked_bytes);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1566
      }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1567
      failures += 1;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1568
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1569
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1570
    // Verify the bit, for this region, in the actual and expected
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1571
    // (which was just calculated) region bit maps.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1572
    // We're not OK if the bit in the calculated expected region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1573
    // bitmap is set and the bit in the actual region bitmap is not.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1574
    BitMap::idx_t index = (BitMap::idx_t) hr->hrs_index();
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1575
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1576
    bool expected = _exp_region_bm->at(index);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1577
    bool actual = _region_bm->at(index);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1578
    if (expected && !actual) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1579
      if (_verbose) {
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1580
        gclog_or_tty->print_cr("Region %u: region bitmap mismatch: "
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1581
                               "expected: %s, actual: %s",
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1582
                               hr->hrs_index(),
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1583
                               BOOL_TO_STR(expected), BOOL_TO_STR(actual));
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1584
      }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1585
      failures += 1;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1586
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1587
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1588
    // Verify that the card bit maps for the cards spanned by the current
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1589
    // region match. We have an error if we have a set bit in the expected
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1590
    // bit map and the corresponding bit in the actual bitmap is not set.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1591
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1592
    BitMap::idx_t start_idx = _cm->card_bitmap_index_for(hr->bottom());
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1593
    BitMap::idx_t end_idx = _cm->card_bitmap_index_for(hr->top());
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1594
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1595
    for (BitMap::idx_t i = start_idx; i < end_idx; i+=1) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1596
      expected = _exp_card_bm->at(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1597
      actual = _card_bm->at(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1598
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1599
      if (expected && !actual) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1600
        if (_verbose) {
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1601
          gclog_or_tty->print_cr("Region %u: card bitmap mismatch at " SIZE_FORMAT ": "
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1602
                                 "expected: %s, actual: %s",
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1603
                                 hr->hrs_index(), i,
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1604
                                 BOOL_TO_STR(expected), BOOL_TO_STR(actual));
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1605
        }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1606
        failures += 1;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1607
      }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1608
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1609
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1610
    if (failures > 0 && _verbose)  {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1611
      gclog_or_tty->print_cr("Region " HR_FORMAT ", ntams: " PTR_FORMAT ", "
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1612
                             "marked_bytes: calc/actual " SIZE_FORMAT "/" SIZE_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  1613
                             HR_FORMAT_PARAMS(hr), p2i(hr->next_top_at_mark_start()),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1614
                             _calc_cl.region_marked_bytes(), hr->next_marked_bytes());
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1615
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1616
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1617
    _failures += failures;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1618
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1619
    // We could stop iteration over the heap when we
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1620
    // find the first violating region by returning true.
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1621
    return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1622
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1623
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1624
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1625
class G1ParVerifyFinalCountTask: public AbstractGangTask {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1626
protected:
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1627
  G1CollectedHeap* _g1h;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1628
  ConcurrentMark* _cm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1629
  BitMap* _actual_region_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1630
  BitMap* _actual_card_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1631
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1632
  uint    _n_workers;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1633
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1634
  BitMap* _expected_region_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1635
  BitMap* _expected_card_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1636
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1637
  int  _failures;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1638
  bool _verbose;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1639
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1640
public:
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1641
  G1ParVerifyFinalCountTask(G1CollectedHeap* g1h,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1642
                            BitMap* region_bm, BitMap* card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1643
                            BitMap* expected_region_bm, BitMap* expected_card_bm)
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1644
    : AbstractGangTask("G1 verify final counting"),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1645
      _g1h(g1h), _cm(_g1h->concurrent_mark()),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1646
      _actual_region_bm(region_bm), _actual_card_bm(card_bm),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1647
      _expected_region_bm(expected_region_bm), _expected_card_bm(expected_card_bm),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1648
      _failures(0), _verbose(false),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1649
      _n_workers(0) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1650
    assert(VerifyDuringGC, "don't call this otherwise");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1651
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1652
    // Use the value already set as the number of active threads
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1653
    // in the call to run_task().
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1654
    if (G1CollectedHeap::use_parallel_gc_threads()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1655
      assert( _g1h->workers()->active_workers() > 0,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1656
        "Should have been previously set");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1657
      _n_workers = _g1h->workers()->active_workers();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1658
    } else {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1659
      _n_workers = 1;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1660
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1661
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1662
    assert(_expected_card_bm->size() == _actual_card_bm->size(), "sanity");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1663
    assert(_expected_region_bm->size() == _actual_region_bm->size(), "sanity");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1664
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1665
    _verbose = _cm->verbose_medium();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1666
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1667
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1668
  void work(uint worker_id) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1669
    assert(worker_id < _n_workers, "invariant");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1670
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1671
    VerifyLiveObjectDataHRClosure verify_cl(_g1h,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1672
                                            _actual_region_bm, _actual_card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1673
                                            _expected_region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1674
                                            _expected_card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1675
                                            _verbose);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1676
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1677
    if (G1CollectedHeap::use_parallel_gc_threads()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1678
      _g1h->heap_region_par_iterate_chunked(&verify_cl,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1679
                                            worker_id,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1680
                                            _n_workers,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1681
                                            HeapRegion::VerifyCountClaimValue);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1682
    } else {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1683
      _g1h->heap_region_iterate(&verify_cl);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1684
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1685
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1686
    Atomic::add(verify_cl.failures(), &_failures);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1687
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1688
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1689
  int failures() const { return _failures; }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1690
};
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1691
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1692
// Closure that finalizes the liveness counting data.
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1693
// Used during the cleanup pause.
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1694
// Sets the bits corresponding to the interval [NTAMS, top]
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1695
// (which contains the implicitly live objects) in the
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1696
// card liveness bitmap. Also sets the bit for each region,
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1697
// containing live data, in the region liveness bitmap.
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1698
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1699
class FinalCountDataUpdateClosure: public CMCountDataClosureBase {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1700
 public:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1701
  FinalCountDataUpdateClosure(G1CollectedHeap* g1h,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1702
                              BitMap* region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1703
                              BitMap* card_bm) :
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1704
    CMCountDataClosureBase(g1h, region_bm, card_bm) { }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1705
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1706
  bool doHeapRegion(HeapRegion* hr) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1707
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1708
    if (hr->continuesHumongous()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1709
      // We will ignore these here and process them when their
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1710
      // associated "starts humongous" region is processed (see
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1711
      // set_bit_for_heap_region()). Note that we cannot rely on their
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1712
      // associated "starts humongous" region to have their bit set to
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1713
      // 1 since, due to the region chunking in the parallel region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1714
      // iteration, a "continues humongous" region might be visited
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1715
      // before its associated "starts humongous".
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1716
      return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1717
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1718
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1719
    HeapWord* ntams = hr->next_top_at_mark_start();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1720
    HeapWord* top   = hr->top();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1721
12508
d76458352d62 7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents: 12382
diff changeset
  1722
    assert(hr->bottom() <= ntams && ntams <= hr->end(), "Preconditions.");
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1723
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1724
    // Mark the allocated-since-marking portion...
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1725
    if (ntams < top) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1726
      // This definitely means the region has live objects.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1727
      set_bit_for_region(hr);
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1728
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1729
      // Now set the bits in the card bitmap for [ntams, top)
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1730
      BitMap::idx_t start_idx = _cm->card_bitmap_index_for(ntams);
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1731
      BitMap::idx_t end_idx = _cm->card_bitmap_index_for(top);
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1732
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1733
      // Note: if we're looking at the last region in heap - top
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1734
      // could be actually just beyond the end of the heap; end_idx
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1735
      // will then correspond to a (non-existent) card that is also
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1736
      // just beyond the heap.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1737
      if (_g1h->is_in_g1_reserved(top) && !_ct_bs->is_card_aligned(top)) {
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1738
        // end of object is not card aligned - increment to cover
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1739
        // all the cards spanned by the object
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1740
        end_idx += 1;
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1741
      }
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1742
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1743
      assert(end_idx <= _card_bm->size(),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1744
             err_msg("oob: end_idx=  "SIZE_FORMAT", bitmap size= "SIZE_FORMAT,
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1745
                     end_idx, _card_bm->size()));
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1746
      assert(start_idx < _card_bm->size(),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1747
             err_msg("oob: start_idx=  "SIZE_FORMAT", bitmap size= "SIZE_FORMAT,
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1748
                     start_idx, _card_bm->size()));
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1749
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1750
      _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13336
diff changeset
  1751
    }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1752
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1753
    // Set the bit for the region if it contains live data
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1754
    if (hr->next_marked_bytes() > 0) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1755
      set_bit_for_region(hr);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1756
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1757
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1758
    return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1759
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1760
};
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1761
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1762
class G1ParFinalCountTask: public AbstractGangTask {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1763
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1764
  G1CollectedHeap* _g1h;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1765
  ConcurrentMark* _cm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1766
  BitMap* _actual_region_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1767
  BitMap* _actual_card_bm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1768
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1769
  uint    _n_workers;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1770
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1771
public:
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1772
  G1ParFinalCountTask(G1CollectedHeap* g1h, BitMap* region_bm, BitMap* card_bm)
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1773
    : AbstractGangTask("G1 final counting"),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1774
      _g1h(g1h), _cm(_g1h->concurrent_mark()),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1775
      _actual_region_bm(region_bm), _actual_card_bm(card_bm),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1776
      _n_workers(0) {
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1777
    // Use the value already set as the number of active threads
12382
6aaecb1cbfe1 7145441: G1: collection set chooser-related cleanup
tonyp
parents: 12381
diff changeset
  1778
    // in the call to run_task().
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1779
    if (G1CollectedHeap::use_parallel_gc_threads()) {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1780
      assert( _g1h->workers()->active_workers() > 0,
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1781
        "Should have been previously set");
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1782
      _n_workers = _g1h->workers()->active_workers();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1783
    } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1784
      _n_workers = 1;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  1785
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1786
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1787
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1788
  void work(uint worker_id) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1789
    assert(worker_id < _n_workers, "invariant");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1790
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  1791
    FinalCountDataUpdateClosure final_update_cl(_g1h,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1792
                                                _actual_region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1793
                                                _actual_card_bm);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1794
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  1795
    if (G1CollectedHeap::use_parallel_gc_threads()) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1796
      _g1h->heap_region_par_iterate_chunked(&final_update_cl,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1797
                                            worker_id,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1798
                                            _n_workers,
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  1799
                                            HeapRegion::FinalCountClaimValue);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1800
    } else {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1801
      _g1h->heap_region_iterate(&final_update_cl);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1802
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1803
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1804
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1805
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1806
class G1ParNoteEndTask;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1807
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1808
class G1NoteEndOfConcMarkClosure : public HeapRegionClosure {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1809
  G1CollectedHeap* _g1;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1810
  size_t _max_live_bytes;
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1811
  uint _regions_claimed;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1812
  size_t _freed_bytes;
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1813
  FreeRegionList* _local_cleanup_list;
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1814
  HeapRegionSetCount _old_regions_removed;
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1815
  HeapRegionSetCount _humongous_regions_removed;
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1816
  HRRSCleanupTask* _hrrs_cleanup_task;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1817
  double _claimed_region_time;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1818
  double _max_region_time;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1819
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1820
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1821
  G1NoteEndOfConcMarkClosure(G1CollectedHeap* g1,
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1822
                             FreeRegionList* local_cleanup_list,
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1823
                             HRRSCleanupTask* hrrs_cleanup_task) :
23855
c4574075402c 8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents: 23505
diff changeset
  1824
    _g1(g1),
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1825
    _max_live_bytes(0), _regions_claimed(0),
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1826
    _freed_bytes(0),
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1827
    _claimed_region_time(0.0), _max_region_time(0.0),
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1828
    _local_cleanup_list(local_cleanup_list),
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1829
    _old_regions_removed(),
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1830
    _humongous_regions_removed(),
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1831
    _hrrs_cleanup_task(hrrs_cleanup_task) { }
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1832
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1833
  size_t freed_bytes() { return _freed_bytes; }
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1834
  const HeapRegionSetCount& old_regions_removed() { return _old_regions_removed; }
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1835
  const HeapRegionSetCount& humongous_regions_removed() { return _humongous_regions_removed; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1836
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1837
  bool doHeapRegion(HeapRegion *hr) {
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1838
    if (hr->continuesHumongous()) {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1839
      return false;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1840
    }
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1841
    // We use a claim value of zero here because all regions
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1842
    // were claimed with value 1 in the FinalCount task.
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1843
    _g1->reset_gc_time_stamps(hr);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1844
    double start = os::elapsedTime();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1845
    _regions_claimed++;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1846
    hr->note_end_of_marking();
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1847
    _max_live_bytes += hr->max_live_bytes();
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1848
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1849
    if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1850
      _freed_bytes += hr->used();
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1851
      hr->set_containing_set(NULL);
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1852
      if (hr->isHumongous()) {
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1853
        assert(hr->startsHumongous(), "we should only see starts humongous");
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1854
        _humongous_regions_removed.increment(1u, hr->capacity());
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1855
        _g1->free_humongous_region(hr, _local_cleanup_list, true);
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1856
      } else {
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1857
        _old_regions_removed.increment(1u, hr->capacity());
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1858
        _g1->free_region(hr, _local_cleanup_list, true);
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1859
      }
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1860
    } else {
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1861
      hr->rem_set()->do_cleanup_work(_hrrs_cleanup_task);
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1862
    }
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1863
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1864
    double region_time = (os::elapsedTime() - start);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1865
    _claimed_region_time += region_time;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1866
    if (region_time > _max_region_time) {
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  1867
      _max_region_time = region_time;
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1868
    }
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1869
    return false;
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  1870
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1871
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1872
  size_t max_live_bytes() { return _max_live_bytes; }
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  1873
  uint regions_claimed() { return _regions_claimed; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1874
  double claimed_region_time_sec() { return _claimed_region_time; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1875
  double max_region_time_sec() { return _max_region_time; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1876
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1877
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1878
class G1ParNoteEndTask: public AbstractGangTask {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1879
  friend class G1NoteEndOfConcMarkClosure;
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1880
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1881
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1882
  G1CollectedHeap* _g1h;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1883
  size_t _max_live_bytes;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1884
  size_t _freed_bytes;
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1885
  FreeRegionList* _cleanup_list;
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1886
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1887
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1888
  G1ParNoteEndTask(G1CollectedHeap* g1h,
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1889
                   FreeRegionList* cleanup_list) :
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1890
    AbstractGangTask("G1 note end"), _g1h(g1h),
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1891
    _max_live_bytes(0), _freed_bytes(0), _cleanup_list(cleanup_list) { }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1892
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1893
  void work(uint worker_id) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1894
    double start = os::elapsedTime();
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1895
    FreeRegionList local_cleanup_list("Local Cleanup List");
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1896
    HRRSCleanupTask hrrs_cleanup_task;
23855
c4574075402c 8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents: 23505
diff changeset
  1897
    G1NoteEndOfConcMarkClosure g1_note_end(_g1h, &local_cleanup_list,
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1898
                                           &hrrs_cleanup_task);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  1899
    if (G1CollectedHeap::use_parallel_gc_threads()) {
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1900
      _g1h->heap_region_par_iterate_chunked(&g1_note_end, worker_id,
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1901
                                            _g1h->workers()->active_workers(),
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  1902
                                            HeapRegion::NoteEndClaimValue);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1903
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1904
      _g1h->heap_region_iterate(&g1_note_end);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1905
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1906
    assert(g1_note_end.complete(), "Shouldn't have yielded!");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1907
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1908
    // Now update the lists
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1909
    _g1h->remove_from_old_sets(g1_note_end.old_regions_removed(), g1_note_end.humongous_regions_removed());
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1910
    {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1911
      MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag);
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1912
      _g1h->decrement_summary_bytes(g1_note_end.freed_bytes());
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1913
      _max_live_bytes += g1_note_end.max_live_bytes();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1914
      _freed_bytes += g1_note_end.freed_bytes();
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1915
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1916
      // If we iterate over the global cleanup list at the end of
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1917
      // cleanup to do this printing we will not guarantee to only
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1918
      // generate output for the newly-reclaimed regions (the list
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1919
      // might not be empty at the beginning of cleanup; we might
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1920
      // still be working on its previous contents). So we do the
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1921
      // printing here, before we append the new regions to the global
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1922
      // cleanup list.
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1923
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1924
      G1HRPrinter* hr_printer = _g1h->hr_printer();
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1925
      if (hr_printer->is_active()) {
23450
c7c6202fc7e2 8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents: 22551
diff changeset
  1926
        FreeRegionListIterator iter(&local_cleanup_list);
10001
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1927
        while (iter.more_available()) {
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1928
          HeapRegion* hr = iter.get_next();
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1929
          hr_printer->cleanup(hr);
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1930
        }
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1931
      }
8aa7f885326e 7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents: 9999
diff changeset
  1932
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23463
diff changeset
  1933
      _cleanup_list->add_ordered(&local_cleanup_list);
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1934
      assert(local_cleanup_list.is_empty(), "post-condition");
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1935
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1936
      HeapRegionRemSet::finish_cleanup_task(&hrrs_cleanup_task);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1937
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1938
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1939
  size_t max_live_bytes() { return _max_live_bytes; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1940
  size_t freed_bytes() { return _freed_bytes; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1941
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1942
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1943
class G1ParScrubRemSetTask: public AbstractGangTask {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1944
protected:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1945
  G1RemSet* _g1rs;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1946
  BitMap* _region_bm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1947
  BitMap* _card_bm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1948
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1949
  G1ParScrubRemSetTask(G1CollectedHeap* g1h,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1950
                       BitMap* region_bm, BitMap* card_bm) :
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1951
    AbstractGangTask("G1 ScrubRS"), _g1rs(g1h->g1_rem_set()),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1952
    _region_bm(region_bm), _card_bm(card_bm) { }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1953
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1954
  void work(uint worker_id) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  1955
    if (G1CollectedHeap::use_parallel_gc_threads()) {
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1956
      _g1rs->scrub_par(_region_bm, _card_bm, worker_id,
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  1957
                       HeapRegion::ScrubRemSetClaimValue);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1958
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1959
      _g1rs->scrub(_region_bm, _card_bm);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1960
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1961
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1962
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1963
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1964
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1965
void ConcurrentMark::cleanup() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1966
  // world is stopped at this checkpoint
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1967
  assert(SafepointSynchronize::is_at_safepoint(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1968
         "world should be stopped");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1969
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1970
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1971
  // If a full collection has happened, we shouldn't do this.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1972
  if (has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1973
    g1h->set_marking_complete(); // So bitmap clearing isn't confused
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1974
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1975
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1976
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1977
  g1h->verify_region_sets_optional();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  1978
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1979
  if (VerifyDuringGC) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1980
    HandleMark hm;  // handle scope
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1981
    Universe::heap()->prepare_for_verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1982
    Universe::verify(VerifyOption_G1UsePrevMarking,
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  1983
                     " VerifyDuringGC:(before)");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1984
  }
24244
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  1985
  g1h->check_bitmaps("Cleanup Start");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  1986
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1987
  G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1988
  g1p->record_concurrent_mark_cleanup_start();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1989
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1990
  double start = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1991
8072
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1992
  HeapRegionRemSet::reset_for_cleanup_tasks();
f223f43cd62f 7014261: G1: RSet-related failures
tonyp
parents: 7923
diff changeset
  1993
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  1994
  uint n_workers;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  1995
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  1996
  // Do counting once more with the world stopped for good measure.
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1997
  G1ParFinalCountTask g1_par_count_task(g1h, &_region_bm, &_card_bm);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  1998
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  1999
  if (G1CollectedHeap::use_parallel_gc_threads()) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2000
   assert(g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2001
           "sanity check");
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2002
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  2003
    g1h->set_par_threads();
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  2004
    n_workers = g1h->n_par_threads();
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2005
    assert(g1h->n_par_threads() == n_workers,
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  2006
           "Should not have been reset");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2007
    g1h->workers()->run_task(&g1_par_count_task);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2008
    // Done with the parallel phase so reset to 0.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2009
    g1h->set_par_threads(0);
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2010
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2011
    assert(g1h->check_heap_region_claim_values(HeapRegion::FinalCountClaimValue),
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2012
           "sanity check");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2013
  } else {
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  2014
    n_workers = 1;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2015
    g1_par_count_task.work(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2016
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2017
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2018
  if (VerifyDuringGC) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2019
    // Verify that the counting data accumulated during marking matches
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2020
    // that calculated by walking the marking bitmap.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2021
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2022
    // Bitmaps to hold expected values
23505
b3c5e757bbb7 8037958: ConcurrentMark::cleanup leaks BitMaps if VerifyDuringGC is enabled
mgerdin
parents: 23471
diff changeset
  2023
    BitMap expected_region_bm(_region_bm.size(), true);
b3c5e757bbb7 8037958: ConcurrentMark::cleanup leaks BitMaps if VerifyDuringGC is enabled
mgerdin
parents: 23471
diff changeset
  2024
    BitMap expected_card_bm(_card_bm.size(), true);
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2025
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2026
    G1ParVerifyFinalCountTask g1_par_verify_task(g1h,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2027
                                                 &_region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2028
                                                 &_card_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2029
                                                 &expected_region_bm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2030
                                                 &expected_card_bm);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2031
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2032
    if (G1CollectedHeap::use_parallel_gc_threads()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2033
      g1h->set_par_threads((int)n_workers);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2034
      g1h->workers()->run_task(&g1_par_verify_task);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2035
      // Done with the parallel phase so reset to 0.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2036
      g1h->set_par_threads(0);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2037
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2038
      assert(g1h->check_heap_region_claim_values(HeapRegion::VerifyCountClaimValue),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2039
             "sanity check");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2040
    } else {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2041
      g1_par_verify_task.work(0);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2042
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2043
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2044
    guarantee(g1_par_verify_task.failures() == 0, "Unexpected accounting failures");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2045
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  2046
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2047
  size_t start_used_bytes = g1h->used();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2048
  g1h->set_marking_complete();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2049
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2050
  double count_end = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2051
  double this_final_counting_time = (count_end - start);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2052
  _total_counting_time += this_final_counting_time;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2053
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  2054
  if (G1PrintRegionLivenessInfo) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  2055
    G1PrintRegionLivenessInfoClosure cl(gclog_or_tty, "Post-Marking");
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  2056
    _g1h->heap_region_iterate(&cl);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  2057
  }
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  2058
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2059
  // Install newly created mark bitMap as "prev".
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2060
  swapMarkBitMaps();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2061
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2062
  g1h->reset_gc_time_stamp();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2063
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2064
  // Note end of marking in all heap regions.
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2065
  G1ParNoteEndTask g1_par_note_end_task(g1h, &_cleanup_list);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  2066
  if (G1CollectedHeap::use_parallel_gc_threads()) {
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2067
    g1h->set_par_threads((int)n_workers);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2068
    g1h->workers()->run_task(&g1_par_note_end_task);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2069
    g1h->set_par_threads(0);
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2070
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2071
    assert(g1h->check_heap_region_claim_values(HeapRegion::NoteEndClaimValue),
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2072
           "sanity check");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2073
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2074
    g1_par_note_end_task.work(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2075
  }
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2076
  g1h->check_gc_time_stamps();
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2077
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2078
  if (!cleanup_list_is_empty()) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2079
    // The cleanup list is not empty, so we'll have to process it
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2080
    // concurrently. Notify anyone else that might be wanting free
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2081
    // regions that there will be more free regions coming soon.
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2082
    g1h->set_free_regions_coming();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2083
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2084
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2085
  // call below, since it affects the metric by which we sort the heap
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2086
  // regions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2087
  if (G1ScrubRemSets) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2088
    double rs_scrub_start = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2089
    G1ParScrubRemSetTask g1_par_scrub_rs_task(g1h, &_region_bm, &_card_bm);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  2090
    if (G1CollectedHeap::use_parallel_gc_threads()) {
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2091
      g1h->set_par_threads((int)n_workers);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2092
      g1h->workers()->run_task(&g1_par_scrub_rs_task);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2093
      g1h->set_par_threads(0);
1387
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2094
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2095
      assert(g1h->check_heap_region_claim_values(
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2096
                                            HeapRegion::ScrubRemSetClaimValue),
580d4ae0a776 6722565: G1: assert !r->is_on_unclean_list() fires
tonyp
parents: 1375
diff changeset
  2097
             "sanity check");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2098
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2099
      g1_par_scrub_rs_task.work(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2100
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2101
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2102
    double rs_scrub_end = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2103
    double this_rs_scrub_time = (rs_scrub_end - rs_scrub_start);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2104
    _total_rs_scrub_time += this_rs_scrub_time;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2105
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2106
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2107
  // this will also free any regions totally full of garbage objects,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2108
  // and sort the regions.
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2109
  g1h->g1_policy()->record_concurrent_mark_cleanup_end((int)n_workers);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2110
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2111
  // Statistics.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2112
  double end = os::elapsedTime();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2113
  _cleanup_times.add((end - start) * 1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2114
12378
ed44b9ecfa2f 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 12272
diff changeset
  2115
  if (G1Log::fine()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2116
    g1h->print_size_transition(gclog_or_tty,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2117
                               start_used_bytes,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2118
                               g1h->used(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2119
                               g1h->capacity());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2120
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2121
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2122
  // Clean up will have freed any regions completely full of garbage.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2123
  // Update the soft reference policy with the new heap occupancy.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2124
  Universe::update_heap_info_at_gc();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2125
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2126
  // We need to make this be a "collection" so any collection pause that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2127
  // races with it goes around and waits for completeCleanup to finish.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2128
  g1h->increment_total_collections();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2129
11577
0af7e6e062a7 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 11575
diff changeset
  2130
  // We reclaimed old regions so we should calculate the sizes to make
0af7e6e062a7 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 11575
diff changeset
  2131
  // sure we update the old gen/space data.
0af7e6e062a7 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 11575
diff changeset
  2132
  g1h->g1mm()->update_sizes();
0af7e6e062a7 7097586: G1: improve the per-space output when using jmap -heap
tonyp
parents: 11575
diff changeset
  2133
2741
34e2a243d69a 6490395: G1: Tidy up command line flags.
johnc
parents: 2259
diff changeset
  2134
  if (VerifyDuringGC) {
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2135
    HandleMark hm;  // handle scope
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2136
    Universe::heap()->prepare_for_verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  2137
    Universe::verify(VerifyOption_G1UsePrevMarking,
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
  2138
                     " VerifyDuringGC:(after)");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2139
  }
24244
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  2140
  g1h->check_bitmaps("Cleanup End");
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2141
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2142
  g1h->verify_region_sets_optional();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2143
  g1h->trace_heap_after_concurrent_cycle();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2144
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2145
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2146
void ConcurrentMark::completeCleanup() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2147
  if (has_aborted()) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2148
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2149
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2150
23857
f00e672a0531 8039089: List verification enabled in product builds
jwilhelm
parents: 23855
diff changeset
  2151
  _cleanup_list.verify_optional();
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8076
diff changeset
  2152
  FreeRegionList tmp_free_list("Tmp Free List");
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2153
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2154
  if (G1ConcRegionFreeingVerbose) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2155
    gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : "
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  2156
                           "cleanup list has %u entries",
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2157
                           _cleanup_list.length());
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2158
  }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2159
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2160
  // Noone else should be accessing the _cleanup_list at this point,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2161
  // so it's not necessary to take any locks
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2162
  while (!_cleanup_list.is_empty()) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2163
    HeapRegion* hr = _cleanup_list.remove_head();
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23463
diff changeset
  2164
    assert(hr != NULL, "Got NULL from a non-empty list");
9418
32a87dd6b746 7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents: 9417
diff changeset
  2165
    hr->par_clear();
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23463
diff changeset
  2166
    tmp_free_list.add_ordered(hr);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2167
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2168
    // Instead of adding one region at a time to the secondary_free_list,
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2169
    // we accumulate them in the local list and move them a few at a
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2170
    // time. This also cuts down on the number of notify_all() calls
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2171
    // we do during this process. We'll also append the local list when
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2172
    // _cleanup_list is empty (which means we just removed the last
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2173
    // region from the _cleanup_list).
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8076
diff changeset
  2174
    if ((tmp_free_list.length() % G1SecondaryFreeListAppendLength == 0) ||
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2175
        _cleanup_list.is_empty()) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2176
      if (G1ConcRegionFreeingVerbose) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2177
        gclog_or_tty->print_cr("G1ConcRegionFreeing [complete cleanup] : "
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  2178
                               "appending %u entries to the secondary_free_list, "
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  2179
                               "cleanup list still has %u entries",
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8076
diff changeset
  2180
                               tmp_free_list.length(),
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2181
                               _cleanup_list.length());
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2182
      }
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2183
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2184
      {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2185
        MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag);
23471
ec9427262f0a 8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents: 23463
diff changeset
  2186
        g1h->secondary_free_list_add(&tmp_free_list);
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2187
        SecondaryFreeList_lock->notify_all();
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2188
      }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2189
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2190
      if (G1StressConcRegionFreeing) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2191
        for (uintx i = 0; i < G1StressConcRegionFreeingDelayMillis; ++i) {
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2192
          os::sleep(Thread::current(), (jlong) 1, false);
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2193
        }
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  2194
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2195
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2196
  }
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8076
diff changeset
  2197
  assert(tmp_free_list.is_empty(), "post-condition");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2198
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2199
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2200
// Supporting Object and Oop closures for reference discovery
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2201
// and processing in during marking
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2202
7657
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7399
diff changeset
  2203
bool G1CMIsAliveClosure::do_object_b(oop obj) {
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7399
diff changeset
  2204
  HeapWord* addr = (HeapWord*)obj;
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7399
diff changeset
  2205
  return addr != NULL &&
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7399
diff changeset
  2206
         (!_g1->is_in_g1_reserved(addr) || !_g1->is_obj_ill(obj));
a80e571c3d96 7006113: G1: Initialize ReferenceProcessor::_is_alive_non_header field
johnc
parents: 7399
diff changeset
  2207
}
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2208
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2209
// 'Keep Alive' oop closure used by both serial parallel reference processing.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2210
// Uses the CMTask associated with a worker thread (for serial reference
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2211
// processing the CMTask for worker 0 is used) to preserve (mark) and
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2212
// trace referent objects.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2213
//
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2214
// Using the CMTask and embedded local queues avoids having the worker
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2215
// threads operating on the global mark stack. This reduces the risk
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2216
// of overflowing the stack - which we would rather avoid at this late
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2217
// state. Also using the tasks' local queues removes the potential
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2218
// of the workers interfering with each other that could occur if
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2219
// operating on the global stack.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2220
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2221
class G1CMKeepAliveAndDrainClosure: public OopClosure {
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2222
  ConcurrentMark* _cm;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2223
  CMTask*         _task;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2224
  int             _ref_counter_limit;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2225
  int             _ref_counter;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2226
  bool            _is_serial;
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2227
 public:
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2228
  G1CMKeepAliveAndDrainClosure(ConcurrentMark* cm, CMTask* task, bool is_serial) :
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2229
    _cm(cm), _task(task), _is_serial(is_serial),
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2230
    _ref_counter_limit(G1RefProcDrainInterval) {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2231
    assert(_ref_counter_limit > 0, "sanity");
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2232
    assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code");
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2233
    _ref_counter = _ref_counter_limit;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2234
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2235
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2236
  virtual void do_oop(narrowOop* p) { do_oop_work(p); }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2237
  virtual void do_oop(      oop* p) { do_oop_work(p); }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2238
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2239
  template <class T> void do_oop_work(T* p) {
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2240
    if (!_cm->has_overflown()) {
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2241
      oop obj = oopDesc::load_decode_heap_oop(p);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2242
      if (_cm->verbose_high()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2243
        gclog_or_tty->print_cr("\t[%u] we're looking at location "
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2244
                               "*"PTR_FORMAT" = "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2245
                               _task->worker_id(), p2i(p), p2i((void*) obj));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2246
      }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2247
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2248
      _task->deal_with_reference(obj);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2249
      _ref_counter--;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2250
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2251
      if (_ref_counter == 0) {
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2252
        // We have dealt with _ref_counter_limit references, pushing them
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2253
        // and objects reachable from them on to the local stack (and
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2254
        // possibly the global stack). Call CMTask::do_marking_step() to
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2255
        // process these entries.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2256
        //
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2257
        // We call CMTask::do_marking_step() in a loop, which we'll exit if
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2258
        // there's nothing more to do (i.e. we're done with the entries that
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2259
        // were pushed as a result of the CMTask::deal_with_reference() calls
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2260
        // above) or we overflow.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2261
        //
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2262
        // Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2263
        // flag while there may still be some work to do. (See the comment at
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2264
        // the beginning of CMTask::do_marking_step() for those conditions -
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2265
        // one of which is reaching the specified time target.) It is only
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2266
        // when CMTask::do_marking_step() returns without setting the
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2267
        // has_aborted() flag that the marking step has completed.
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2268
        do {
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2269
          double mark_step_duration_ms = G1ConcMarkStepDurationMillis;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2270
          _task->do_marking_step(mark_step_duration_ms,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2271
                                 false      /* do_termination */,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2272
                                 _is_serial);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2273
        } while (_task->has_aborted() && !_cm->has_overflown());
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2274
        _ref_counter = _ref_counter_limit;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2275
      }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2276
    } else {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2277
      if (_cm->verbose_high()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2278
         gclog_or_tty->print_cr("\t[%u] CM Overflow", _task->worker_id());
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2279
      }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2280
    }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2281
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2282
};
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2283
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2284
// 'Drain' oop closure used by both serial and parallel reference processing.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2285
// Uses the CMTask associated with a given worker thread (for serial
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2286
// reference processing the CMtask for worker 0 is used). Calls the
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2287
// do_marking_step routine, with an unbelievably large timeout value,
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2288
// to drain the marking data structures of the remaining entries
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2289
// added by the 'keep alive' oop closure above.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2290
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2291
class G1CMDrainMarkingStackClosure: public VoidClosure {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2292
  ConcurrentMark* _cm;
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2293
  CMTask*         _task;
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2294
  bool            _is_serial;
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2295
 public:
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2296
  G1CMDrainMarkingStackClosure(ConcurrentMark* cm, CMTask* task, bool is_serial) :
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2297
    _cm(cm), _task(task), _is_serial(is_serial) {
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2298
    assert(!_is_serial || _task->worker_id() == 0, "only task 0 for serial code");
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2299
  }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2300
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2301
  void do_void() {
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2302
    do {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2303
      if (_cm->verbose_high()) {
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2304
        gclog_or_tty->print_cr("\t[%u] Drain: Calling do_marking_step - serial: %s",
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2305
                               _task->worker_id(), BOOL_TO_STR(_is_serial));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2306
      }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2307
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2308
      // We call CMTask::do_marking_step() to completely drain the local
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2309
      // and global marking stacks of entries pushed by the 'keep alive'
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2310
      // oop closure (an instance of G1CMKeepAliveAndDrainClosure above).
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2311
      //
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2312
      // CMTask::do_marking_step() is called in a loop, which we'll exit
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  2313
      // if there's nothing more to do (i.e. we've completely drained the
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2314
      // entries that were pushed as a a result of applying the 'keep alive'
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2315
      // closure to the entries on the discovered ref lists) or we overflow
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2316
      // the global marking stack.
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2317
      //
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2318
      // Note: CMTask::do_marking_step() can set the CMTask::has_aborted()
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2319
      // flag while there may still be some work to do. (See the comment at
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2320
      // the beginning of CMTask::do_marking_step() for those conditions -
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2321
      // one of which is reaching the specified time target.) It is only
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2322
      // when CMTask::do_marking_step() returns without setting the
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2323
      // has_aborted() flag that the marking step has completed.
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2324
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2325
      _task->do_marking_step(1000000000.0 /* something very large */,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2326
                             true         /* do_termination */,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2327
                             _is_serial);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2328
    } while (_task->has_aborted() && !_cm->has_overflown());
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2329
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2330
};
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2331
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2332
// Implementation of AbstractRefProcTaskExecutor for parallel
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2333
// reference processing at the end of G1 concurrent marking
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2334
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2335
class G1CMRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2336
private:
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2337
  G1CollectedHeap* _g1h;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2338
  ConcurrentMark*  _cm;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2339
  WorkGang*        _workers;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2340
  int              _active_workers;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2341
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2342
public:
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2343
  G1CMRefProcTaskExecutor(G1CollectedHeap* g1h,
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2344
                        ConcurrentMark* cm,
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2345
                        WorkGang* workers,
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2346
                        int n_workers) :
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2347
    _g1h(g1h), _cm(cm),
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2348
    _workers(workers), _active_workers(n_workers) { }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2349
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2350
  // Executes the given task using concurrent marking worker threads.
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2351
  virtual void execute(ProcessTask& task);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2352
  virtual void execute(EnqueueTask& task);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2353
};
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2354
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2355
class G1CMRefProcTaskProxy: public AbstractGangTask {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2356
  typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2357
  ProcessTask&     _proc_task;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2358
  G1CollectedHeap* _g1h;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2359
  ConcurrentMark*  _cm;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2360
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2361
public:
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2362
  G1CMRefProcTaskProxy(ProcessTask& proc_task,
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2363
                     G1CollectedHeap* g1h,
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2364
                     ConcurrentMark* cm) :
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2365
    AbstractGangTask("Process reference objects in parallel"),
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2366
    _proc_task(proc_task), _g1h(g1h), _cm(cm) {
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2367
    ReferenceProcessor* rp = _g1h->ref_processor_cm();
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2368
    assert(rp->processing_is_mt(), "shouldn't be here otherwise");
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2369
  }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2370
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2371
  virtual void work(uint worker_id) {
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2372
    CMTask* task = _cm->task(worker_id);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2373
    G1CMIsAliveClosure g1_is_alive(_g1h);
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2374
    G1CMKeepAliveAndDrainClosure g1_par_keep_alive(_cm, task, false /* is_serial */);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2375
    G1CMDrainMarkingStackClosure g1_par_drain(_cm, task, false /* is_serial */);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2376
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2377
    _proc_task.work(worker_id, g1_is_alive, g1_par_keep_alive, g1_par_drain);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2378
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2379
};
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2380
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2381
void G1CMRefProcTaskExecutor::execute(ProcessTask& proc_task) {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2382
  assert(_workers != NULL, "Need parallel worker threads.");
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2383
  assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2384
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2385
  G1CMRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _cm);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2386
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2387
  // We need to reset the concurrency level before each
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2388
  // proxy task execution, so that the termination protocol
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2389
  // and overflow handling in CMTask::do_marking_step() knows
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2390
  // how many workers to wait for.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2391
  _cm->set_concurrency(_active_workers);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2392
  _g1h->set_par_threads(_active_workers);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2393
  _workers->run_task(&proc_task_proxy);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2394
  _g1h->set_par_threads(0);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2395
}
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2396
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2397
class G1CMRefEnqueueTaskProxy: public AbstractGangTask {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2398
  typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2399
  EnqueueTask& _enq_task;
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2400
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2401
public:
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2402
  G1CMRefEnqueueTaskProxy(EnqueueTask& enq_task) :
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2403
    AbstractGangTask("Enqueue reference objects in parallel"),
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2404
    _enq_task(enq_task) { }
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2405
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2406
  virtual void work(uint worker_id) {
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2407
    _enq_task.work(worker_id);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2408
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2409
};
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2410
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2411
void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2412
  assert(_workers != NULL, "Need parallel worker threads.");
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2413
  assert(_g1h->ref_processor_cm()->processing_is_mt(), "processing is not MT");
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2414
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2415
  G1CMRefEnqueueTaskProxy enq_task_proxy(enq_task);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2416
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2417
  // Not strictly necessary but...
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2418
  //
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2419
  // We need to reset the concurrency level before each
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2420
  // proxy task execution, so that the termination protocol
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2421
  // and overflow handling in CMTask::do_marking_step() knows
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2422
  // how many workers to wait for.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2423
  _cm->set_concurrency(_active_workers);
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2424
  _g1h->set_par_threads(_active_workers);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2425
  _workers->run_task(&enq_task_proxy);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2426
  _g1h->set_par_threads(0);
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2427
}
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2428
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2429
void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2430
  if (has_overflown()) {
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2431
    // Skip processing the discovered references if we have
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2432
    // overflown the global marking stack. Reference objects
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2433
    // only get discovered once so it is OK to not
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2434
    // de-populate the discovered reference lists. We could have,
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2435
    // but the only benefit would be that, when marking restarts,
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2436
    // less reference objects are discovered.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2437
    return;
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2438
  }
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2439
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2440
  ResourceMark rm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2441
  HandleMark   hm;
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2442
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2443
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2444
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2445
  // Is alive closure.
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2446
  G1CMIsAliveClosure g1_is_alive(g1h);
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2447
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2448
  // Inner scope to exclude the cleaning of the string and symbol
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2449
  // tables from the displayed time.
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2450
  {
12378
ed44b9ecfa2f 7160728: Introduce an extra logging level for G1 logging
brutisso
parents: 12272
diff changeset
  2451
    if (G1Log::finer()) {
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2452
      gclog_or_tty->put(' ');
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2453
    }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2454
    GCTraceTime t("GC ref-proc", G1Log::finer(), false, g1h->gc_timer_cm());
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2455
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2456
    ReferenceProcessor* rp = g1h->ref_processor_cm();
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2457
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2458
    // See the comment in G1CollectedHeap::ref_processing_init()
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2459
    // about how reference processing currently works in G1.
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2460
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2461
    // Set the soft reference policy
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2462
    rp->setup_policy(clear_all_soft_refs);
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2463
    assert(_markStack.isEmpty(), "mark stack should be empty");
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2464
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2465
    // Instances of the 'Keep Alive' and 'Complete GC' closures used
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2466
    // in serial reference processing. Note these closures are also
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2467
    // used for serially processing (by the the current thread) the
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2468
    // JNI references during parallel reference processing.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2469
    //
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2470
    // These closures do not need to synchronize with the worker
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2471
    // threads involved in parallel reference processing as these
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2472
    // instances are executed serially by the current thread (e.g.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2473
    // reference processing is not multi-threaded and is thus
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2474
    // performed by the current thread instead of a gang worker).
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2475
    //
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  2476
    // The gang tasks involved in parallel reference processing create
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2477
    // their own instances of these closures, which do their own
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2478
    // synchronization among themselves.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2479
    G1CMKeepAliveAndDrainClosure g1_keep_alive(this, task(0), true /* is_serial */);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2480
    G1CMDrainMarkingStackClosure g1_drain_mark_stack(this, task(0), true /* is_serial */);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2481
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2482
    // We need at least one active thread. If reference processing
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2483
    // is not multi-threaded we use the current (VMThread) thread,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2484
    // otherwise we use the work gang from the G1CollectedHeap and
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2485
    // we utilize all the worker threads we can.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2486
    bool processing_is_mt = rp->processing_is_mt() && g1h->workers() != NULL;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2487
    uint active_workers = (processing_is_mt ? g1h->workers()->active_workers() : 1U);
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2488
    active_workers = MAX2(MIN2(active_workers, _max_worker_id), 1U);
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2489
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2490
    // Parallel processing task executor.
11172
f720721985ba 7111795: G1: Various cleanups identified during walk through of changes for 6484965
johnc
parents: 10996
diff changeset
  2491
    G1CMRefProcTaskExecutor par_task_executor(g1h, this,
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2492
                                              g1h->workers(), active_workers);
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2493
    AbstractRefProcTaskExecutor* executor = (processing_is_mt ? &par_task_executor : NULL);
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2494
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2495
    // Set the concurrency level. The phase was already set prior to
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2496
    // executing the remark task.
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2497
    set_concurrency(active_workers);
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2498
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2499
    // Set the degree of MT processing here.  If the discovery was done MT,
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2500
    // the number of threads involved during discovery could differ from
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2501
    // the number of active workers.  This is OK as long as the discovered
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2502
    // Reference lists are balanced (see balance_all_queues() and balance_queues()).
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2503
    rp->set_active_mt_degree(active_workers);
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2504
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2505
    // Process the weak references.
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2506
    const ReferenceProcessorStats& stats =
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2507
        rp->process_discovered_references(&g1_is_alive,
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2508
                                          &g1_keep_alive,
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2509
                                          &g1_drain_mark_stack,
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2510
                                          executor,
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2511
                                          g1h->gc_timer_cm());
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  2512
    g1h->gc_tracer_cm()->report_gc_reference_stats(stats);
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2513
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2514
    // The do_oop work routines of the keep_alive and drain_marking_stack
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2515
    // oop closures will set the has_overflown flag if we overflow the
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2516
    // global marking stack.
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2517
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2518
    assert(_markStack.overflow() || _markStack.isEmpty(),
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2519
            "mark stack should be empty (unless it overflowed)");
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2520
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2521
    if (_markStack.overflow()) {
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2522
      // This should have been done already when we tried to push an
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2523
      // entry on to the global mark stack. But let's do it again.
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2524
      set_has_overflown();
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2525
    }
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2526
15495
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2527
    assert(rp->num_q() == active_workers, "why not");
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2528
d791a8e8cf6b 8005032: G1: Cleanup serial reference processing closures in concurrent marking
johnc
parents: 15489
diff changeset
  2529
    rp->enqueue_discovered_references(executor);
10666
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2530
1fd33ec0e5f7 7068215: G1: Print reference processing time during remark
johnc
parents: 10523
diff changeset
  2531
    rp->verify_no_references_recorded();
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  2532
    assert(!rp->discovery_enabled(), "Post condition");
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2533
  }
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2534
23463
8a9ab140068a 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 23450
diff changeset
  2535
  if (has_overflown()) {
8a9ab140068a 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 23450
diff changeset
  2536
    // We can not trust g1_is_alive if the marking stack overflowed
8a9ab140068a 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 23450
diff changeset
  2537
    return;
8a9ab140068a 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 23450
diff changeset
  2538
  }
8a9ab140068a 8036673: G1: Abort weak reference processing if mark stack overflows
pliden
parents: 23450
diff changeset
  2539
22546
9b5f5de1ff7b 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 22545
diff changeset
  2540
  g1h->unlink_string_and_symbol_table(&g1_is_alive,
9b5f5de1ff7b 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 22545
diff changeset
  2541
                                      /* process_strings */ false, // currently strings are always roots
9b5f5de1ff7b 8027454: Do not traverse string table during G1 remark when treating them as strong roots during initial mark
tschatzl
parents: 22545
diff changeset
  2542
                                      /* process_symbols */ true);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2543
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2544
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2545
void ConcurrentMark::swapMarkBitMaps() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2546
  CMBitMapRO* temp = _prevMarkBitMap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2547
  _prevMarkBitMap  = (CMBitMapRO*)_nextMarkBitMap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2548
  _nextMarkBitMap  = (CMBitMap*)  temp;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2549
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2550
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2551
class CMRemarkTask: public AbstractGangTask {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2552
private:
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2553
  ConcurrentMark* _cm;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2554
  bool            _is_serial;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2555
public:
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2556
  void work(uint worker_id) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2557
    // Since all available tasks are actually started, we should
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  2558
    // only proceed if we're supposed to be active.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2559
    if (worker_id < _cm->active_tasks()) {
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2560
      CMTask* task = _cm->task(worker_id);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2561
      task->record_start_time();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2562
      do {
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  2563
        task->do_marking_step(1000000000.0 /* something very large */,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2564
                              true         /* do_termination       */,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2565
                              _is_serial);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2566
      } while (task->has_aborted() && !_cm->has_overflown());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2567
      // If we overflow, then we do not want to restart. We instead
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2568
      // want to abort remark and do concurrent marking again.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2569
      task->record_end_time();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2570
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2571
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2572
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2573
  CMRemarkTask(ConcurrentMark* cm, int active_workers, bool is_serial) :
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2574
    AbstractGangTask("Par Remark"), _cm(cm), _is_serial(is_serial) {
11250
ef1ab0772513 7120038: G1: ParallelGCThreads==0 is broken
johnc
parents: 11176
diff changeset
  2575
    _cm->terminator()->reset_for_reuse(active_workers);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2576
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2577
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2578
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2579
void ConcurrentMark::checkpointRootsFinalWork() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2580
  ResourceMark rm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2581
  HandleMark   hm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2582
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2583
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2584
  g1h->ensure_parsability(false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2585
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  2586
  if (G1CollectedHeap::use_parallel_gc_threads()) {
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3612
diff changeset
  2587
    G1CollectedHeap::StrongRootsScope srs(g1h);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2588
    // this is remark, so we'll use up all active threads
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2589
    uint active_workers = g1h->workers()->active_workers();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2590
    if (active_workers == 0) {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2591
      assert(active_workers > 0, "Should have been set earlier");
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2592
      active_workers = (uint) ParallelGCThreads;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2593
      g1h->workers()->set_active_workers(active_workers);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2594
    }
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2595
    set_concurrency_and_phase(active_workers, false /* concurrent */);
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2596
    // Leave _parallel_marking_threads at it's
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2597
    // value originally calculated in the ConcurrentMark
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2598
    // constructor and pass values of the active workers
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2599
    // through the gang in the task.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2600
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2601
    CMRemarkTask remarkTask(this, active_workers, false /* is_serial */);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2602
    // We will start all available threads, even if we decide that the
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2603
    // active_workers will be fewer. The extra ones will just bail out
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2604
    // immediately.
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 11172
diff changeset
  2605
    g1h->set_par_threads(active_workers);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2606
    g1h->workers()->run_task(&remarkTask);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2607
    g1h->set_par_threads(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2608
  } else {
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 3612
diff changeset
  2609
    G1CollectedHeap::StrongRootsScope srs(g1h);
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  2610
    uint active_workers = 1;
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  2611
    set_concurrency_and_phase(active_workers, false /* concurrent */);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2612
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2613
    // Note - if there's no work gang then the VMThread will be
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2614
    // the thread to execute the remark - serially. We have
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2615
    // to pass true for the is_serial parameter so that
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2616
    // CMTask::do_marking_step() doesn't enter the sync
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2617
    // barriers in the event of an overflow. Doing so will
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2618
    // cause an assert that the current thread is not a
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2619
    // concurrent GC thread.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  2620
    CMRemarkTask remarkTask(this, active_workers, true /* is_serial*/);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2621
    remarkTask.work(0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2622
  }
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2623
  SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
16390
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  2624
  guarantee(has_overflown() ||
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  2625
            satb_mq_set.completed_buffers_num() == 0,
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  2626
            err_msg("Invariant: has_overflown = %s, num buffers = %d",
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  2627
                    BOOL_TO_STR(has_overflown()),
848861a059be 8008301: G1: guarantee(satb_mq_set.completed_buffers_num() == 0) failure
johnc
parents: 16389
diff changeset
  2628
                    satb_mq_set.completed_buffers_num()));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2629
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2630
  print_stats();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2631
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2632
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2633
#ifndef PRODUCT
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2634
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2635
class PrintReachableOopClosure: public OopClosure {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2636
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2637
  G1CollectedHeap* _g1h;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2638
  outputStream*    _out;
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2639
  VerifyOption     _vo;
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2640
  bool             _all;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2641
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2642
public:
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2643
  PrintReachableOopClosure(outputStream* out,
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2644
                           VerifyOption  vo,
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2645
                           bool          all) :
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2646
    _g1h(G1CollectedHeap::heap()),
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2647
    _out(out), _vo(vo), _all(all) { }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2648
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2649
  void do_oop(narrowOop* p) { do_oop_work(p); }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2650
  void do_oop(      oop* p) { do_oop_work(p); }
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2651
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2652
  template <class T> void do_oop_work(T* p) {
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 3184
diff changeset
  2653
    oop         obj = oopDesc::load_decode_heap_oop(p);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2654
    const char* str = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2655
    const char* str2 = "";
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2656
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2657
    if (obj == NULL) {
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2658
      str = "";
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2659
    } else if (!_g1h->is_in_g1_reserved(obj)) {
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2660
      str = " O";
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2661
    } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2662
      HeapRegion* hr  = _g1h->heap_region_containing(obj);
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2663
      bool over_tams = _g1h->allocated_since_marking(obj, hr, _vo);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2664
      bool marked = _g1h->is_marked(obj, _vo);
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2665
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2666
      if (over_tams) {
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2667
        str = " >";
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2668
        if (marked) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2669
          str2 = " AND MARKED";
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2670
        }
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2671
      } else if (marked) {
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2672
        str = " M";
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2673
      } else {
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2674
        str = " NOT";
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2675
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2676
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2677
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2678
    _out->print_cr("  "PTR_FORMAT": "PTR_FORMAT"%s%s",
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2679
                   p2i(p), p2i((void*) obj), str, str2);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2680
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2681
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2682
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2683
class PrintReachableObjectClosure : public ObjectClosure {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2684
private:
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2685
  G1CollectedHeap* _g1h;
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2686
  outputStream*    _out;
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2687
  VerifyOption     _vo;
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2688
  bool             _all;
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2689
  HeapRegion*      _hr;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2690
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2691
public:
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2692
  PrintReachableObjectClosure(outputStream* out,
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2693
                              VerifyOption  vo,
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2694
                              bool          all,
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2695
                              HeapRegion*   hr) :
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2696
    _g1h(G1CollectedHeap::heap()),
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2697
    _out(out), _vo(vo), _all(all), _hr(hr) { }
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2698
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2699
  void do_object(oop o) {
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2700
    bool over_tams = _g1h->allocated_since_marking(o, _hr, _vo);
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2701
    bool marked = _g1h->is_marked(o, _vo);
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2702
    bool print_it = _all || over_tams || marked;
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2703
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2704
    if (print_it) {
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2705
      _out->print_cr(" "PTR_FORMAT"%s",
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2706
                     p2i((void *)o), (over_tams) ? " >" : (marked) ? " M" : "");
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2707
      PrintReachableOopClosure oopCl(_out, _vo, _all);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13336
diff changeset
  2708
      o->oop_iterate_no_header(&oopCl);
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2709
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2710
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2711
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2712
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2713
class PrintReachableRegionClosure : public HeapRegionClosure {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2714
private:
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2715
  G1CollectedHeap* _g1h;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2716
  outputStream*    _out;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2717
  VerifyOption     _vo;
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2718
  bool             _all;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2719
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2720
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2721
  bool doHeapRegion(HeapRegion* hr) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2722
    HeapWord* b = hr->bottom();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2723
    HeapWord* e = hr->end();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2724
    HeapWord* t = hr->top();
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2725
    HeapWord* p = _g1h->top_at_mark_start(hr, _vo);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2726
    _out->print_cr("** ["PTR_FORMAT", "PTR_FORMAT"] top: "PTR_FORMAT" "
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2727
                   "TAMS: " PTR_FORMAT, p2i(b), p2i(e), p2i(t), p2i(p));
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2728
    _out->cr();
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2729
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2730
    HeapWord* from = b;
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2731
    HeapWord* to   = t;
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2732
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2733
    if (to > from) {
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2734
      _out->print_cr("Objects in [" PTR_FORMAT ", " PTR_FORMAT "]", p2i(from), p2i(to));
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2735
      _out->cr();
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2736
      PrintReachableObjectClosure ocl(_out, _vo, _all, hr);
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2737
      hr->object_iterate_mem_careful(MemRegion(from, to), &ocl);
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2738
      _out->cr();
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2739
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2740
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2741
    return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2742
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2743
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2744
  PrintReachableRegionClosure(outputStream* out,
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2745
                              VerifyOption  vo,
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2746
                              bool          all) :
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2747
    _g1h(G1CollectedHeap::heap()), _out(out), _vo(vo), _all(all) { }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2748
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2749
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2750
void ConcurrentMark::print_reachable(const char* str,
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2751
                                     VerifyOption vo,
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2752
                                     bool all) {
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2753
  gclog_or_tty->cr();
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2754
  gclog_or_tty->print_cr("== Doing heap dump... ");
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2755
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2756
  if (G1PrintReachableBaseFile == NULL) {
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2757
    gclog_or_tty->print_cr("  #### error: no base file defined");
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2758
    return;
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2759
  }
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2760
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2761
  if (strlen(G1PrintReachableBaseFile) + 1 + strlen(str) >
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2762
      (JVM_MAXPATHLEN - 1)) {
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2763
    gclog_or_tty->print_cr("  #### error: file name too long");
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2764
    return;
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2765
  }
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2766
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2767
  char file_name[JVM_MAXPATHLEN];
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2768
  sprintf(file_name, "%s.%s", G1PrintReachableBaseFile, str);
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2769
  gclog_or_tty->print_cr("  dumping to file %s", file_name);
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2770
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2771
  fileStream fout(file_name);
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2772
  if (!fout.is_open()) {
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2773
    gclog_or_tty->print_cr("  #### error: could not open file");
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2774
    return;
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2775
  }
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2776
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2777
  outputStream* out = &fout;
13336
e582172ff6ff 7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents: 13289
diff changeset
  2778
  out->print_cr("-- USING %s", _g1h->top_at_mark_start_str(vo));
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2779
  out->cr();
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2780
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2781
  out->print_cr("--- ITERATING OVER REGIONS");
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2782
  out->cr();
9995
290620c08233 7004681: G1: Extend marking verification to Full GCs
johnc
parents: 9994
diff changeset
  2783
  PrintReachableRegionClosure rcl(out, vo, all);
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2784
  _g1h->heap_region_iterate(&rcl);
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2785
  out->cr();
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2786
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2787
  gclog_or_tty->print_cr("  done");
5344
f78ef2531f44 6937142: G1: improvements to debugging output (S-M)
tonyp
parents: 5243
diff changeset
  2788
  gclog_or_tty->flush();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2789
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2790
4099
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2791
#endif // PRODUCT
77d31ea5a439 6890137: G1: revamp reachable object dump
tonyp
parents: 4033
diff changeset
  2792
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2793
void ConcurrentMark::clearRangePrevBitmap(MemRegion mr) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2794
  // Note we are overriding the read-only view of the prev map here, via
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2795
  // the cast.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2796
  ((CMBitMap*)_prevMarkBitMap)->clearRange(mr);
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2797
}
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2798
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2799
void ConcurrentMark::clearRangeNextBitmap(MemRegion mr) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2800
  _nextMarkBitMap->clearRange(mr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2801
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2802
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2803
void ConcurrentMark::clearRangeBothBitmaps(MemRegion mr) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2804
  clearRangePrevBitmap(mr);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2805
  clearRangeNextBitmap(mr);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2806
}
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2807
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2808
HeapRegion*
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2809
ConcurrentMark::claim_region(uint worker_id) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2810
  // "checkpoint" the finger
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2811
  HeapWord* finger = _finger;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2812
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2813
  // _heap_end will not change underneath our feet; it only changes at
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2814
  // yield points.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2815
  while (finger < _heap_end) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2816
    assert(_g1h->is_in_g1_reserved(finger), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2817
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2818
    // Note on how this code handles humongous regions. In the
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2819
    // normal case the finger will reach the start of a "starts
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2820
    // humongous" (SH) region. Its end will either be the end of the
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2821
    // last "continues humongous" (CH) region in the sequence, or the
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2822
    // standard end of the SH region (if the SH is the only region in
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2823
    // the sequence). That way claim_region() will skip over the CH
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2824
    // regions. However, there is a subtle race between a CM thread
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2825
    // executing this method and a mutator thread doing a humongous
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2826
    // object allocation. The two are not mutually exclusive as the CM
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2827
    // thread does not need to hold the Heap_lock when it gets
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2828
    // here. So there is a chance that claim_region() will come across
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2829
    // a free region that's in the progress of becoming a SH or a CH
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2830
    // region. In the former case, it will either
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2831
    //   a) Miss the update to the region's end, in which case it will
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2832
    //      visit every subsequent CH region, will find their bitmaps
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2833
    //      empty, and do nothing, or
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2834
    //   b) Will observe the update of the region's end (in which case
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2835
    //      it will skip the subsequent CH regions).
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2836
    // If it comes across a region that suddenly becomes CH, the
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2837
    // scenario will be similar to b). So, the race between
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2838
    // claim_region() and a humongous object allocation might force us
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2839
    // to do a bit of unnecessary work (due to some unnecessary bitmap
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2840
    // iterations) but it should not introduce and correctness issues.
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2841
    HeapRegion* curr_region   = _g1h->heap_region_containing_raw(finger);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2842
    HeapWord*   bottom        = curr_region->bottom();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2843
    HeapWord*   end           = curr_region->end();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2844
    HeapWord*   limit         = curr_region->next_top_at_mark_start();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2845
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2846
    if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2847
      gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2848
                             "["PTR_FORMAT", "PTR_FORMAT"), "
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2849
                             "limit = "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2850
                             worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit));
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2851
    }
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2852
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2853
    // Is the gap between reading the finger and doing the CAS too long?
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  2854
    HeapWord* res = (HeapWord*) Atomic::cmpxchg_ptr(end, &_finger, finger);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2855
    if (res == finger) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2856
      // we succeeded
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2857
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2858
      // notice that _finger == end cannot be guaranteed here since,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2859
      // someone else might have moved the finger even further
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2860
      assert(_finger >= end, "the finger should have moved forward");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2861
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2862
      if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2863
        gclog_or_tty->print_cr("[%u] we were successful with region = "
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2864
                               PTR_FORMAT, worker_id, p2i(curr_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2865
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2866
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2867
      if (limit > bottom) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2868
        if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2869
          gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, "
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2870
                                 "returning it ", worker_id, p2i(curr_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2871
        }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2872
        return curr_region;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2873
      } else {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2874
        assert(limit == bottom,
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2875
               "the region limit should be at bottom");
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2876
        if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2877
          gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, "
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2878
                                 "returning NULL", worker_id, p2i(curr_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2879
        }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2880
        // we return NULL and the caller should try calling
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2881
        // claim_region() again.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2882
        return NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2883
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2884
    } else {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  2885
      assert(_finger > finger, "the finger should have moved forward");
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2886
      if (verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2887
        gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2888
                               "global finger = "PTR_FORMAT", "
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2889
                               "our finger = "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2890
                               worker_id, p2i(_finger), p2i(finger));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  2891
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2892
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2893
      // read it again
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2894
      finger = _finger;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2895
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2896
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2897
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2898
  return NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2899
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2900
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2901
#ifndef PRODUCT
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2902
enum VerifyNoCSetOopsPhase {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2903
  VerifyNoCSetOopsStack,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2904
  VerifyNoCSetOopsQueues,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2905
  VerifyNoCSetOopsSATBCompleted,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2906
  VerifyNoCSetOopsSATBThread
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2907
};
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2908
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2909
class VerifyNoCSetOopsClosure : public OopClosure, public ObjectClosure  {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2910
private:
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2911
  G1CollectedHeap* _g1h;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2912
  VerifyNoCSetOopsPhase _phase;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2913
  int _info;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2914
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2915
  const char* phase_str() {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2916
    switch (_phase) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2917
    case VerifyNoCSetOopsStack:         return "Stack";
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2918
    case VerifyNoCSetOopsQueues:        return "Queue";
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2919
    case VerifyNoCSetOopsSATBCompleted: return "Completed SATB Buffers";
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2920
    case VerifyNoCSetOopsSATBThread:    return "Thread SATB Buffers";
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2921
    default:                            ShouldNotReachHere();
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2922
    }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2923
    return NULL;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2924
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2925
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2926
  void do_object_work(oop obj) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2927
    guarantee(!_g1h->obj_in_cs(obj),
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2928
              err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d",
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  2929
                      p2i((void*) obj), phase_str(), _info));
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2930
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2931
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2932
public:
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2933
  VerifyNoCSetOopsClosure() : _g1h(G1CollectedHeap::heap()) { }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2934
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2935
  void set_phase(VerifyNoCSetOopsPhase phase, int info = -1) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2936
    _phase = phase;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2937
    _info = info;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2938
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2939
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2940
  virtual void do_oop(oop* p) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2941
    oop obj = oopDesc::load_decode_heap_oop(p);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2942
    do_object_work(obj);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2943
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2944
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2945
  virtual void do_oop(narrowOop* p) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2946
    // We should not come across narrow oops while scanning marking
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2947
    // stacks and SATB buffers.
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2948
    ShouldNotReachHere();
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2949
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2950
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2951
  virtual void do_object(oop obj) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2952
    do_object_work(obj);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2953
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2954
};
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2955
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2956
void ConcurrentMark::verify_no_cset_oops(bool verify_stacks,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2957
                                         bool verify_enqueued_buffers,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2958
                                         bool verify_thread_buffers,
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2959
                                         bool verify_fingers) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2960
  assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2961
  if (!G1CollectedHeap::heap()->mark_in_progress()) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2962
    return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  2963
  }
6761
f9191297ce83 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 6759
diff changeset
  2964
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2965
  VerifyNoCSetOopsClosure cl;
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2966
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2967
  if (verify_stacks) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2968
    // Verify entries on the global mark stack
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2969
    cl.set_phase(VerifyNoCSetOopsStack);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2970
    _markStack.oops_do(&cl);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2971
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2972
    // Verify entries on the task queues
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  2973
    for (uint i = 0; i < _max_worker_id; i += 1) {
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2974
      cl.set_phase(VerifyNoCSetOopsQueues, i);
14740
1431ef92fed1 8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents: 14076
diff changeset
  2975
      CMTaskQueue* queue = _task_queues->queue(i);
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2976
      queue->oops_do(&cl);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2977
    }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2978
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2979
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2980
  SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2981
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2982
  // Verify entries on the enqueued SATB buffers
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2983
  if (verify_enqueued_buffers) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2984
    cl.set_phase(VerifyNoCSetOopsSATBCompleted);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2985
    satb_qs.iterate_completed_buffers_read_only(&cl);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2986
  }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2987
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2988
  // Verify entries on the per-thread SATB buffers
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2989
  if (verify_thread_buffers) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2990
    cl.set_phase(VerifyNoCSetOopsSATBThread);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2991
    satb_qs.iterate_thread_buffers_read_only(&cl);
6761
f9191297ce83 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 6759
diff changeset
  2992
  }
f9191297ce83 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 6759
diff changeset
  2993
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2994
  if (verify_fingers) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2995
    // Verify the global finger
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2996
    HeapWord* global_finger = finger();
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2997
    if (global_finger != NULL && global_finger < _heap_end) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2998
      // The global finger always points to a heap region boundary. We
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  2999
      // use heap_region_containing_raw() to get the containing region
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3000
      // given that the global finger could be pointing to a free region
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3001
      // which subsequently becomes continues humongous. If that
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3002
      // happens, heap_region_containing() will return the bottom of the
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3003
      // corresponding starts humongous region and the check below will
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3004
      // not hold any more.
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3005
      HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3006
      guarantee(global_finger == global_hr->bottom(),
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3007
                err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3008
                        p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3009
    }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3010
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3011
    // Verify the task fingers
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3012
    assert(parallel_marking_threads() <= _max_worker_id, "sanity");
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3013
    for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3014
      CMTask* task = _tasks[i];
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3015
      HeapWord* task_finger = task->finger();
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3016
      if (task_finger != NULL && task_finger < _heap_end) {
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3017
        // See above note on the global finger verification.
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3018
        HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3019
        guarantee(task_finger == task_hr->bottom() ||
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3020
                  !task_hr->in_collection_set(),
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3021
                  err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3022
                          p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3023
      }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3024
    }
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3025
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3026
}
11455
a6ab3d8b9a4c 6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents: 11451
diff changeset
  3027
#endif // PRODUCT
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3028
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3029
// Aggregate the counting data that was constructed concurrently
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3030
// with marking.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3031
class AggregateCountDataHRClosure: public HeapRegionClosure {
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3032
  G1CollectedHeap* _g1h;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3033
  ConcurrentMark* _cm;
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3034
  CardTableModRefBS* _ct_bs;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3035
  BitMap* _cm_card_bm;
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3036
  uint _max_worker_id;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3037
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3038
 public:
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3039
  AggregateCountDataHRClosure(G1CollectedHeap* g1h,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3040
                              BitMap* cm_card_bm,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3041
                              uint max_worker_id) :
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3042
    _g1h(g1h), _cm(g1h->concurrent_mark()),
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3043
    _ct_bs((CardTableModRefBS*) (g1h->barrier_set())),
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3044
    _cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3045
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3046
  bool doHeapRegion(HeapRegion* hr) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3047
    if (hr->continuesHumongous()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3048
      // We will ignore these here and process them when their
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3049
      // associated "starts humongous" region is processed.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3050
      // Note that we cannot rely on their associated
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3051
      // "starts humongous" region to have their bit set to 1
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3052
      // since, due to the region chunking in the parallel region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3053
      // iteration, a "continues humongous" region might be visited
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3054
      // before its associated "starts humongous".
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3055
      return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3056
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3057
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3058
    HeapWord* start = hr->bottom();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3059
    HeapWord* limit = hr->next_top_at_mark_start();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3060
    HeapWord* end = hr->end();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3061
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3062
    assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3063
           err_msg("Preconditions not met - "
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3064
                   "start: "PTR_FORMAT", limit: "PTR_FORMAT", "
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3065
                   "top: "PTR_FORMAT", end: "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3066
                   p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end())));
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3067
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3068
    assert(hr->next_marked_bytes() == 0, "Precondition");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3069
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3070
    if (start == limit) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3071
      // NTAMS of this region has not been set so nothing to do.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3072
      return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3073
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3074
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3075
    // 'start' should be in the heap.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3076
    assert(_g1h->is_in_g1_reserved(start) && _ct_bs->is_card_aligned(start), "sanity");
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  3077
    // 'end' *may* be just beyond the end of the heap (if hr is the last region)
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3078
    assert(!_g1h->is_in_g1_reserved(end) || _ct_bs->is_card_aligned(end), "sanity");
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3079
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3080
    BitMap::idx_t start_idx = _cm->card_bitmap_index_for(start);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3081
    BitMap::idx_t limit_idx = _cm->card_bitmap_index_for(limit);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3082
    BitMap::idx_t end_idx = _cm->card_bitmap_index_for(end);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3083
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3084
    // If ntams is not card aligned then we bump card bitmap index
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3085
    // for limit so that we get the all the cards spanned by
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3086
    // the object ending at ntams.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3087
    // Note: if this is the last region in the heap then ntams
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3088
    // could be actually just beyond the end of the the heap;
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3089
    // limit_idx will then  correspond to a (non-existent) card
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3090
    // that is also outside the heap.
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3091
    if (_g1h->is_in_g1_reserved(limit) && !_ct_bs->is_card_aligned(limit)) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3092
      limit_idx += 1;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3093
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3094
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3095
    assert(limit_idx <= end_idx, "or else use atomics");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3096
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3097
    // Aggregate the "stripe" in the count data associated with hr.
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  3098
    uint hrs_index = hr->hrs_index();
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3099
    size_t marked_bytes = 0;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3100
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3101
    for (uint i = 0; i < _max_worker_id; i += 1) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3102
      size_t* marked_bytes_array = _cm->count_marked_bytes_array_for(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3103
      BitMap* task_card_bm = _cm->count_card_bitmap_for(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3104
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3105
      // Fetch the marked_bytes in this region for task i and
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3106
      // add it to the running total for this region.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3107
      marked_bytes += marked_bytes_array[hrs_index];
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3108
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3109
      // Now union the bitmaps[0,max_worker_id)[start_idx..limit_idx)
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3110
      // into the global card bitmap.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3111
      BitMap::idx_t scan_idx = task_card_bm->get_next_one_offset(start_idx, limit_idx);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3112
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3113
      while (scan_idx < limit_idx) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3114
        assert(task_card_bm->at(scan_idx) == true, "should be");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3115
        _cm_card_bm->set_bit(scan_idx);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3116
        assert(_cm_card_bm->at(scan_idx) == true, "should be");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3117
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3118
        // BitMap::get_next_one_offset() can handle the case when
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3119
        // its left_offset parameter is greater than its right_offset
13919
01f6d01a9004 7200261: G1: Liveness counting inconsistencies during marking verification
johnc
parents: 13752
diff changeset
  3120
        // parameter. It does, however, have an early exit if
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3121
        // left_offset == right_offset. So let's limit the value
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3122
        // passed in for left offset here.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3123
        BitMap::idx_t next_idx = MIN2(scan_idx + 1, limit_idx);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3124
        scan_idx = task_card_bm->get_next_one_offset(next_idx, limit_idx);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3125
      }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3126
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3127
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3128
    // Update the marked bytes for this region.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3129
    hr->add_to_marked_bytes(marked_bytes);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3130
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3131
    // Next heap region
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3132
    return false;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3133
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3134
};
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3135
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3136
class G1AggregateCountDataTask: public AbstractGangTask {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3137
protected:
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3138
  G1CollectedHeap* _g1h;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3139
  ConcurrentMark* _cm;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3140
  BitMap* _cm_card_bm;
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3141
  uint _max_worker_id;
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3142
  int _active_workers;
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3143
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3144
public:
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3145
  G1AggregateCountDataTask(G1CollectedHeap* g1h,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3146
                           ConcurrentMark* cm,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3147
                           BitMap* cm_card_bm,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3148
                           uint max_worker_id,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3149
                           int n_workers) :
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3150
    AbstractGangTask("Count Aggregation"),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3151
    _g1h(g1h), _cm(cm), _cm_card_bm(cm_card_bm),
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3152
    _max_worker_id(max_worker_id),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3153
    _active_workers(n_workers) { }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3154
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3155
  void work(uint worker_id) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3156
    AggregateCountDataHRClosure cl(_g1h, _cm_card_bm, _max_worker_id);
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3157
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3158
    if (G1CollectedHeap::use_parallel_gc_threads()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3159
      _g1h->heap_region_par_iterate_chunked(&cl, worker_id,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3160
                                            _active_workers,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3161
                                            HeapRegion::AggregateCountClaimValue);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3162
    } else {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3163
      _g1h->heap_region_iterate(&cl);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3164
    }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3165
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3166
};
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3167
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3168
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3169
void ConcurrentMark::aggregate_count_data() {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3170
  int n_workers = (G1CollectedHeap::use_parallel_gc_threads() ?
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3171
                        _g1h->workers()->active_workers() :
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3172
                        1);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3173
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3174
  G1AggregateCountDataTask g1_par_agg_task(_g1h, this, &_card_bm,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3175
                                           _max_worker_id, n_workers);
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3176
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3177
  if (G1CollectedHeap::use_parallel_gc_threads()) {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3178
    assert(_g1h->check_heap_region_claim_values(HeapRegion::InitialClaimValue),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3179
           "sanity check");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3180
    _g1h->set_par_threads(n_workers);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3181
    _g1h->workers()->run_task(&g1_par_agg_task);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3182
    _g1h->set_par_threads(0);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3183
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3184
    assert(_g1h->check_heap_region_claim_values(HeapRegion::AggregateCountClaimValue),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3185
           "sanity check");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3186
    _g1h->reset_heap_region_claim_values();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3187
  } else {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3188
    g1_par_agg_task.work(0);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3189
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3190
}
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3191
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3192
// Clear the per-worker arrays used to store the per-region counting data
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3193
void ConcurrentMark::clear_all_count_data() {
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3194
  // Clear the global card bitmap - it will be filled during
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3195
  // liveness count aggregation (during remark) and the
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3196
  // final counting task.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3197
  _card_bm.clear();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3198
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3199
  // Clear the global region bitmap - it will be filled as part
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3200
  // of the final counting task.
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3201
  _region_bm.clear();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3202
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  3203
  uint max_regions = _g1h->max_regions();
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3204
  assert(_max_worker_id > 0, "uninitialized");
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3205
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3206
  for (uint i = 0; i < _max_worker_id; i += 1) {
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3207
    BitMap* task_card_bm = count_card_bitmap_for(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3208
    size_t* marked_bytes_array = count_marked_bytes_array_for(i);
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3209
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3210
    assert(task_card_bm->size() == _card_bm.size(), "size mismatch");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3211
    assert(marked_bytes_array != NULL, "uninitialized");
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3212
12381
1438e0fbfa27 7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents: 12379
diff changeset
  3213
    memset(marked_bytes_array, 0, (size_t) max_regions * sizeof(size_t));
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3214
    task_card_bm->clear();
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3215
  }
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3216
}
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3217
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3218
void ConcurrentMark::print_stats() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3219
  if (verbose_stats()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3220
    gclog_or_tty->print_cr("---------------------------------------------------------------------");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3221
    for (size_t i = 0; i < _active_tasks; ++i) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3222
      _tasks[i]->print_stats();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3223
      gclog_or_tty->print_cr("---------------------------------------------------------------------");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3224
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3225
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3226
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3227
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3228
// abandon current marking iteration due to a Full GC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3229
void ConcurrentMark::abort() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3230
  // Clear all marks to force marking thread to do nothing
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3231
  _nextMarkBitMap->clearAll();
24244
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  3232
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  3233
  // Note we cannot clear the previous marking bitmap here
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  3234
  // since VerifyDuringGC verifies the objects marked during
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  3235
  // a full GC against the previous bitmap.
2c7a1e5649bd 7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents: 24106
diff changeset
  3236
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3237
  // Clear the liveness counting data
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3238
  clear_all_count_data();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3239
  // Empty mark stack
15090
18bfcc1bbe39 8004816: G1: Kitchensink failures after marking stack changes
johnc
parents: 14740
diff changeset
  3240
  reset_marking_state();
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3241
  for (uint i = 0; i < _max_worker_id; ++i) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3242
    _tasks[i]->clear_region_fields();
6761
f9191297ce83 6941395: G1: Use only lock-free versions of region stack push() and pop()
johnc
parents: 6759
diff changeset
  3243
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3244
  _has_aborted = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3245
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3246
  SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3247
  satb_mq_set.abandon_partial_marking();
5082
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  3248
  // This can be called either during or outside marking, we'll read
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  3249
  // the expected_active value from the SATB queue set.
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  3250
  satb_mq_set.set_active_all_threads(
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  3251
                                 false, /* new active value */
19e725a3d2eb 6935821: G1: threads created during marking do not active their SATB queues
tonyp
parents: 5079
diff changeset
  3252
                                 satb_mq_set.is_active() /* expected_active */);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  3253
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  3254
  _g1h->trace_heap_after_concurrent_cycle();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17395
diff changeset
  3255
  _g1h->register_concurrent_cycle_end();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3256
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3257
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3258
static void print_ms_time_info(const char* prefix, const char* name,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3259
                               NumberSeq& ns) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3260
  gclog_or_tty->print_cr("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3261
                         prefix, ns.num(), name, ns.sum()/1000.0, ns.avg());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3262
  if (ns.num() > 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3263
    gclog_or_tty->print_cr("%s         [std. dev = %8.2f ms, max = %8.2f ms]",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3264
                           prefix, ns.sd(), ns.maximum());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3265
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3266
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3267
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3268
void ConcurrentMark::print_summary_info() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3269
  gclog_or_tty->print_cr(" Concurrent marking:");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3270
  print_ms_time_info("  ", "init marks", _init_times);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3271
  print_ms_time_info("  ", "remarks", _remark_times);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3272
  {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3273
    print_ms_time_info("     ", "final marks", _remark_mark_times);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3274
    print_ms_time_info("     ", "weak refs", _remark_weak_ref_times);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3275
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3276
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3277
  print_ms_time_info("  ", "cleanups", _cleanup_times);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3278
  gclog_or_tty->print_cr("    Final counting total time = %8.2f s (avg = %8.2f ms).",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3279
                         _total_counting_time,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3280
                         (_cleanup_times.num() > 0 ? _total_counting_time * 1000.0 /
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3281
                          (double)_cleanup_times.num()
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3282
                         : 0.0));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3283
  if (G1ScrubRemSets) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3284
    gclog_or_tty->print_cr("    RS scrub total time = %8.2f s (avg = %8.2f ms).",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3285
                           _total_rs_scrub_time,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3286
                           (_cleanup_times.num() > 0 ? _total_rs_scrub_time * 1000.0 /
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3287
                            (double)_cleanup_times.num()
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3288
                           : 0.0));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3289
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3290
  gclog_or_tty->print_cr("  Total stop_world time = %8.2f s.",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3291
                         (_init_times.sum() + _remark_times.sum() +
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3292
                          _cleanup_times.sum())/1000.0);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3293
  gclog_or_tty->print_cr("  Total concurrent time = %8.2f s "
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3294
                "(%8.2f s marking).",
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3295
                cmThread()->vtime_accum(),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  3296
                cmThread()->vtime_mark_accum());
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3297
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3298
4022
2ec87d5043f7 6885041: G1: inconsistent thread dump
tonyp
parents: 3912
diff changeset
  3299
void ConcurrentMark::print_worker_threads_on(outputStream* st) const {
15489
0f2bd608c4f2 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 15487
diff changeset
  3300
  if (use_parallel_marking_threads()) {
0f2bd608c4f2 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 15487
diff changeset
  3301
    _parallel_workers->print_worker_threads_on(st);
0f2bd608c4f2 8005875: G1: Kitchensink fails with ParallelGCThreads=0
johnc
parents: 15487
diff changeset
  3302
  }
4022
2ec87d5043f7 6885041: G1: inconsistent thread dump
tonyp
parents: 3912
diff changeset
  3303
}
2ec87d5043f7 6885041: G1: inconsistent thread dump
tonyp
parents: 3912
diff changeset
  3304
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3305
void ConcurrentMark::print_on_error(outputStream* st) const {
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3306
  st->print_cr("Marking Bits (Prev, Next): (CMBitMap*) " PTR_FORMAT ", (CMBitMap*) " PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3307
      p2i(_prevMarkBitMap), p2i(_nextMarkBitMap));
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3308
  _prevMarkBitMap->print_on_error(st, " Prev Bits: ");
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3309
  _nextMarkBitMap->print_on_error(st, " Next Bits: ");
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3310
}
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16390
diff changeset
  3311
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3312
// We take a break if someone is trying to stop the world.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  3313
bool ConcurrentMark::do_yield_check(uint worker_id) {
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  3314
  if (SuspendibleThreadSet::should_yield()) {
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11250
diff changeset
  3315
    if (worker_id == 0) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3316
      _g1h->g1_policy()->record_concurrent_pause();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3317
    }
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  3318
    SuspendibleThreadSet::yield();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3319
    return true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3320
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3321
    return false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3322
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3323
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3324
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3325
bool ConcurrentMark::containing_card_is_marked(void* p) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3326
  size_t offset = pointer_delta(p, _g1h->reserved_region().start(), 1);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3327
  return _card_bm.at(offset >> CardTableModRefBS::card_shift);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3328
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3329
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3330
bool ConcurrentMark::containing_cards_are_marked(void* start,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3331
                                                 void* last) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3332
  return containing_card_is_marked(start) &&
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3333
         containing_card_is_marked(last);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3334
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3335
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3336
#ifndef PRODUCT
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3337
// for debugging purposes
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3338
void ConcurrentMark::print_finger() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3339
  gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3340
                         p2i(_heap_start), p2i(_heap_end), p2i(_finger));
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3341
  for (uint i = 0; i < _max_worker_id; ++i) {
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3342
    gclog_or_tty->print("   %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger()));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3343
  }
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3344
  gclog_or_tty->cr();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3345
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3346
#endif
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3347
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3348
void CMTask::scan_object(oop obj) {
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3349
  assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3350
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3351
  if (_cm->verbose_high()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3352
    gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3353
                           _worker_id, p2i((void*) obj));
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3354
  }
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3355
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3356
  size_t obj_size = obj->size();
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3357
  _words_scanned += obj_size;
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3358
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3359
  obj->oop_iterate(_cm_oop_closure);
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3360
  statsOnly( ++_objs_scanned );
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3361
  check_limits();
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3362
}
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3363
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3364
// Closure for iteration over bitmaps
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3365
class CMBitMapClosure : public BitMapClosure {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3366
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3367
  // the bitmap that is being iterated over
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3368
  CMBitMap*                   _nextMarkBitMap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3369
  ConcurrentMark*             _cm;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3370
  CMTask*                     _task;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3371
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3372
public:
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3373
  CMBitMapClosure(CMTask *task, ConcurrentMark* cm, CMBitMap* nextMarkBitMap) :
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3374
    _task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3375
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3376
  bool do_bit(size_t offset) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3377
    HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset);
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3378
    assert(_nextMarkBitMap->isMarked(addr), "invariant");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3379
    assert( addr < _cm->finger(), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3380
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3381
    statsOnly( _task->increase_objs_found_on_bitmap() );
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3382
    assert(addr >= _task->finger(), "invariant");
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3383
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3384
    // We move that task's local finger along.
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3385
    _task->move_finger_to(addr);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3386
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3387
    _task->scan_object(oop(addr));
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3388
    // we only partially drain the local queue and global stack
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3389
    _task->drain_local_queue(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3390
    _task->drain_global_stack(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3391
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3392
    // if the has_aborted flag has been raised, we need to bail out of
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3393
    // the iteration
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3394
    return !_task->has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3395
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3396
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3397
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3398
// Closure for iterating over objects, currently only used for
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3399
// processing SATB buffers.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3400
class CMObjectClosure : public ObjectClosure {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3401
private:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3402
  CMTask* _task;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3403
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3404
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3405
  void do_object(oop obj) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3406
    _task->deal_with_reference(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3407
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3408
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3409
  CMObjectClosure(CMTask* task) : _task(task) { }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3410
};
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3411
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3412
G1CMOopClosure::G1CMOopClosure(G1CollectedHeap* g1h,
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3413
                               ConcurrentMark* cm,
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3414
                               CMTask* task)
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3415
  : _g1h(g1h), _cm(cm), _task(task) {
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3416
  assert(_ref_processor == NULL, "should be initialized to NULL");
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3417
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3418
  if (G1UseConcMarkReferenceProcessing) {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10668
diff changeset
  3419
    _ref_processor = g1h->ref_processor_cm();
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3420
    assert(_ref_processor != NULL, "should not be NULL");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3421
  }
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3422
}
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3423
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3424
void CMTask::setup_for_region(HeapRegion* hr) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3425
  assert(hr != NULL,
24106
dae9277bdf2a 8040722: G1: Clean up usages of heap_region_containing
brutisso
parents: 24094
diff changeset
  3426
        "claim_region() should have filtered out NULL regions");
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3427
  assert(!hr->continuesHumongous(),
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3428
        "claim_region() should have filtered out continues humongous regions");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3429
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3430
  if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3431
    gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3432
                           _worker_id, p2i(hr));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3433
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3434
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3435
  _curr_region  = hr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3436
  _finger       = hr->bottom();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3437
  update_region_limit();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3438
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3439
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3440
void CMTask::update_region_limit() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3441
  HeapRegion* hr            = _curr_region;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3442
  HeapWord* bottom          = hr->bottom();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3443
  HeapWord* limit           = hr->next_top_at_mark_start();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3444
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3445
  if (limit == bottom) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3446
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3447
      gclog_or_tty->print_cr("[%u] found an empty region "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3448
                             "["PTR_FORMAT", "PTR_FORMAT")",
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3449
                             _worker_id, p2i(bottom), p2i(limit));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3450
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3451
    // The region was collected underneath our feet.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3452
    // We set the finger to bottom to ensure that the bitmap
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3453
    // iteration that will follow this will not do anything.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3454
    // (this is not a condition that holds when we set the region up,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3455
    // as the region is not supposed to be empty in the first place)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3456
    _finger = bottom;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3457
  } else if (limit >= _region_limit) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3458
    assert(limit >= _finger, "peace of mind");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3459
  } else {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3460
    assert(limit < _region_limit, "only way to get here");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3461
    // This can happen under some pretty unusual circumstances.  An
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3462
    // evacuation pause empties the region underneath our feet (NTAMS
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3463
    // at bottom). We then do some allocation in the region (NTAMS
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3464
    // stays at bottom), followed by the region being used as a GC
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3465
    // alloc region (NTAMS will move to top() and the objects
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3466
    // originally below it will be grayed). All objects now marked in
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3467
    // the region are explicitly grayed, if below the global finger,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3468
    // and we do not need in fact to scan anything else. So, we simply
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3469
    // set _finger to be limit to ensure that the bitmap iteration
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3470
    // doesn't do anything.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3471
    _finger = limit;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3472
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3473
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3474
  _region_limit = limit;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3475
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3476
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3477
void CMTask::giveup_current_region() {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3478
  assert(_curr_region != NULL, "invariant");
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3479
  if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3480
    gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3481
                           _worker_id, p2i(_curr_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3482
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3483
  clear_region_fields();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3484
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3485
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3486
void CMTask::clear_region_fields() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3487
  // Values for these three fields that indicate that we're not
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3488
  // holding on to a region.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3489
  _curr_region   = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3490
  _finger        = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3491
  _region_limit  = NULL;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3492
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3493
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3494
void CMTask::set_cm_oop_closure(G1CMOopClosure* cm_oop_closure) {
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3495
  if (cm_oop_closure == NULL) {
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3496
    assert(_cm_oop_closure != NULL, "invariant");
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3497
  } else {
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3498
    assert(_cm_oop_closure == NULL, "invariant");
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3499
  }
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3500
  _cm_oop_closure = cm_oop_closure;
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3501
}
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  3502
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3503
void CMTask::reset(CMBitMap* nextMarkBitMap) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3504
  guarantee(nextMarkBitMap != NULL, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3505
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3506
  if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3507
    gclog_or_tty->print_cr("[%u] resetting", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3508
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3509
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3510
  _nextMarkBitMap                = nextMarkBitMap;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3511
  clear_region_fields();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3512
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3513
  _calls                         = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3514
  _elapsed_time_ms               = 0.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3515
  _termination_time_ms           = 0.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3516
  _termination_start_time_ms     = 0.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3517
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3518
#if _MARKING_STATS_
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3519
  _local_pushes                  = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3520
  _local_pops                    = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3521
  _local_max_size                = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3522
  _objs_scanned                  = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3523
  _global_pushes                 = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3524
  _global_pops                   = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3525
  _global_max_size               = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3526
  _global_transfers_to           = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3527
  _global_transfers_from         = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3528
  _regions_claimed               = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3529
  _objs_found_on_bitmap          = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3530
  _satb_buffers_processed        = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3531
  _steal_attempts                = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3532
  _steals                        = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3533
  _aborted                       = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3534
  _aborted_overflow              = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3535
  _aborted_cm_aborted            = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3536
  _aborted_yield                 = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3537
  _aborted_timed_out             = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3538
  _aborted_satb                  = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3539
  _aborted_termination           = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3540
#endif // _MARKING_STATS_
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3541
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3542
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3543
bool CMTask::should_exit_termination() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3544
  regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3545
  // This is called when we are in the termination protocol. We should
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3546
  // quit if, for some reason, this task wants to abort or the global
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3547
  // stack is not empty (this means that we can get work from it).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3548
  return !_cm->mark_stack_empty() || has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3549
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3550
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3551
void CMTask::reached_limit() {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3552
  assert(_words_scanned >= _words_scanned_limit ||
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3553
         _refs_reached >= _refs_reached_limit ,
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3554
         "shouldn't have been called otherwise");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3555
  regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3556
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3557
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3558
void CMTask::regular_clock_call() {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3559
  if (has_aborted()) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3560
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3561
  // First, we need to recalculate the words scanned and refs reached
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3562
  // limits for the next clock call.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3563
  recalculate_limits();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3564
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3565
  // During the regular clock call we do the following
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3566
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3567
  // (1) If an overflow has been flagged, then we abort.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3568
  if (_cm->has_overflown()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3569
    set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3570
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3571
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3572
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3573
  // If we are not concurrent (i.e. we're doing remark) we don't need
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3574
  // to check anything else. The other steps are only needed during
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3575
  // the concurrent marking phase.
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3576
  if (!concurrent()) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3577
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3578
  // (2) If marking has been aborted for Full GC, then we also abort.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3579
  if (_cm->has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3580
    set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3581
    statsOnly( ++_aborted_cm_aborted );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3582
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3583
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3584
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3585
  double curr_time_ms = os::elapsedVTime() * 1000.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3586
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3587
  // (3) If marking stats are enabled, then we update the step history.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3588
#if _MARKING_STATS_
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3589
  if (_words_scanned >= _words_scanned_limit) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3590
    ++_clock_due_to_scanning;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3591
  }
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3592
  if (_refs_reached >= _refs_reached_limit) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3593
    ++_clock_due_to_marking;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3594
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3595
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3596
  double last_interval_ms = curr_time_ms - _interval_start_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3597
  _interval_start_time_ms = curr_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3598
  _all_clock_intervals_ms.add(last_interval_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3599
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3600
  if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3601
      gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, "
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3602
                        "scanned = %d%s, refs reached = %d%s",
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3603
                        _worker_id, last_interval_ms,
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3604
                        _words_scanned,
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3605
                        (_words_scanned >= _words_scanned_limit) ? " (*)" : "",
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3606
                        _refs_reached,
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3607
                        (_refs_reached >= _refs_reached_limit) ? " (*)" : "");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3608
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3609
#endif // _MARKING_STATS_
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3610
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3611
  // (4) We check whether we should yield. If we have to, then we abort.
24094
5dbf1f44de18 8039147: Cleanup SuspendibleThreadSet
pliden
parents: 24092
diff changeset
  3612
  if (SuspendibleThreadSet::should_yield()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3613
    // We should yield. To do this we abort the task. The caller is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3614
    // responsible for yielding.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3615
    set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3616
    statsOnly( ++_aborted_yield );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3617
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3618
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3619
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3620
  // (5) We check whether we've reached our time quota. If we have,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3621
  // then we abort.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3622
  double elapsed_time_ms = curr_time_ms - _start_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3623
  if (elapsed_time_ms > _time_target_ms) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3624
    set_has_aborted();
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  3625
    _has_timed_out = true;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3626
    statsOnly( ++_aborted_timed_out );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3627
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3628
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3629
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3630
  // (6) Finally, we check whether there are enough completed STAB
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3631
  // buffers available for processing. If there are, we abort.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3632
  SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3633
  if (!_draining_satb_buffers && satb_mq_set.process_completed_buffers()) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3634
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3635
      gclog_or_tty->print_cr("[%u] aborting to deal with pending SATB buffers",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3636
                             _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3637
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3638
    // we do need to process SATB buffers, we'll abort and restart
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3639
    // the marking task to do so
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3640
    set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3641
    statsOnly( ++_aborted_satb );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3642
    return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3643
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3644
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3645
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3646
void CMTask::recalculate_limits() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3647
  _real_words_scanned_limit = _words_scanned + words_scanned_period;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3648
  _words_scanned_limit      = _real_words_scanned_limit;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3649
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3650
  _real_refs_reached_limit  = _refs_reached  + refs_reached_period;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3651
  _refs_reached_limit       = _real_refs_reached_limit;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3652
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3653
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3654
void CMTask::decrease_limits() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3655
  // This is called when we believe that we're going to do an infrequent
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3656
  // operation which will increase the per byte scanned cost (i.e. move
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3657
  // entries to/from the global stack). It basically tries to decrease the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3658
  // scanning limit so that the clock is called earlier.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3659
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3660
  if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3661
    gclog_or_tty->print_cr("[%u] decreasing limits", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3662
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3663
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3664
  _words_scanned_limit = _real_words_scanned_limit -
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3665
    3 * words_scanned_period / 4;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3666
  _refs_reached_limit  = _real_refs_reached_limit -
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3667
    3 * refs_reached_period / 4;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3668
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3669
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3670
void CMTask::move_entries_to_global_stack() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3671
  // local array where we'll store the entries that will be popped
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3672
  // from the local queue
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3673
  oop buffer[global_stack_transfer_size];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3674
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3675
  int n = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3676
  oop obj;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3677
  while (n < global_stack_transfer_size && _task_queue->pop_local(obj)) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3678
    buffer[n] = obj;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3679
    ++n;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3680
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3681
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3682
  if (n > 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3683
    // we popped at least one entry from the local queue
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3684
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3685
    statsOnly( ++_global_transfers_to; _local_pops += n );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3686
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3687
    if (!_cm->mark_stack_push(buffer, n)) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3688
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3689
        gclog_or_tty->print_cr("[%u] aborting due to global stack overflow",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3690
                               _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3691
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3692
      set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3693
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3694
      // the transfer was successful
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3695
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3696
      if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3697
        gclog_or_tty->print_cr("[%u] pushed %d entries to the global stack",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3698
                               _worker_id, n);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3699
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3700
      statsOnly( int tmp_size = _cm->mark_stack_size();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3701
                 if (tmp_size > _global_max_size) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3702
                   _global_max_size = tmp_size;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3703
                 }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3704
                 _global_pushes += n );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3705
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3706
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3707
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3708
  // this operation was quite expensive, so decrease the limits
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3709
  decrease_limits();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3710
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3711
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3712
void CMTask::get_entries_from_global_stack() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3713
  // local array where we'll store the entries that will be popped
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3714
  // from the global stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3715
  oop buffer[global_stack_transfer_size];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3716
  int n;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3717
  _cm->mark_stack_pop(buffer, global_stack_transfer_size, &n);
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3718
  assert(n <= global_stack_transfer_size,
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3719
         "we should not pop more than the given limit");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3720
  if (n > 0) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3721
    // yes, we did actually pop at least one entry
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3722
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3723
    statsOnly( ++_global_transfers_from; _global_pops += n );
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3724
    if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3725
      gclog_or_tty->print_cr("[%u] popped %d entries from the global stack",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3726
                             _worker_id, n);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3727
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3728
    for (int i = 0; i < n; ++i) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3729
      bool success = _task_queue->push(buffer[i]);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3730
      // We only call this when the local queue is empty or under a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3731
      // given target limit. So, we do not expect this push to fail.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3732
      assert(success, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3733
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3734
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3735
    statsOnly( int tmp_size = _task_queue->size();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3736
               if (tmp_size > _local_max_size) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3737
                 _local_max_size = tmp_size;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3738
               }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3739
               _local_pushes += n );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3740
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3741
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3742
  // this operation was quite expensive, so decrease the limits
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3743
  decrease_limits();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3744
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3745
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3746
void CMTask::drain_local_queue(bool partially) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3747
  if (has_aborted()) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3748
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3749
  // Decide what the target size is, depending whether we're going to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3750
  // drain it partially (so that other tasks can steal if they run out
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3751
  // of things to do) or totally (at the very end).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3752
  size_t target_size;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3753
  if (partially) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3754
    target_size = MIN2((size_t)_task_queue->max_elems()/3, GCDrainStackTargetSize);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3755
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3756
    target_size = 0;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3757
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3758
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3759
  if (_task_queue->size() > target_size) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3760
    if (_cm->verbose_high()) {
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23858
diff changeset
  3761
      gclog_or_tty->print_cr("[%u] draining local queue, target size = " SIZE_FORMAT,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3762
                             _worker_id, target_size);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3763
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3764
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3765
    oop obj;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3766
    bool ret = _task_queue->pop_local(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3767
    while (ret) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3768
      statsOnly( ++_local_pops );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3769
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3770
      if (_cm->verbose_high()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3771
        gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  3772
                               p2i((void*) obj));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3773
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3774
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3775
      assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
8680
f1c414e16a4c 7014923: G1: code cleanup
tonyp
parents: 8076
diff changeset
  3776
      assert(!_g1h->is_on_master_free_list(
7923
fc200fcd4e05 6977804: G1: remove the zero-filling thread
tonyp
parents: 7920
diff changeset
  3777
                  _g1h->heap_region_containing((HeapWord*) obj)), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3778
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3779
      scan_object(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3780
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3781
      if (_task_queue->size() <= target_size || has_aborted()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3782
        ret = false;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3783
      } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3784
        ret = _task_queue->pop_local(obj);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3785
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3786
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3787
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3788
    if (_cm->verbose_high()) {
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23858
diff changeset
  3789
      gclog_or_tty->print_cr("[%u] drained local queue, size = %u",
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3790
                             _worker_id, _task_queue->size());
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3791
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3792
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3793
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3794
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3795
void CMTask::drain_global_stack(bool partially) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3796
  if (has_aborted()) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3797
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3798
  // We have a policy to drain the local queue before we attempt to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3799
  // drain the global stack.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3800
  assert(partially || _task_queue->size() == 0, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3801
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3802
  // Decide what the target size is, depending whether we're going to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3803
  // drain it partially (so that other tasks can steal if they run out
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3804
  // of things to do) or totally (at the very end).  Notice that,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3805
  // because we move entries from the global stack in chunks or
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3806
  // because another task might be doing the same, we might in fact
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3807
  // drop below the target. But, this is not a problem.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3808
  size_t target_size;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3809
  if (partially) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3810
    target_size = _cm->partial_mark_stack_size_target();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3811
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3812
    target_size = 0;
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3813
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3814
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3815
  if (_cm->mark_stack_size() > target_size) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3816
    if (_cm->verbose_low()) {
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23858
diff changeset
  3817
      gclog_or_tty->print_cr("[%u] draining global_stack, target size " SIZE_FORMAT,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3818
                             _worker_id, target_size);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3819
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3820
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3821
    while (!has_aborted() && _cm->mark_stack_size() > target_size) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3822
      get_entries_from_global_stack();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3823
      drain_local_queue(partially);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3824
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3825
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3826
    if (_cm->verbose_low()) {
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23858
diff changeset
  3827
      gclog_or_tty->print_cr("[%u] drained global stack, size = " SIZE_FORMAT,
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3828
                             _worker_id, _cm->mark_stack_size());
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3829
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3830
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3831
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3832
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3833
// SATB Queue has several assumptions on whether to call the par or
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3834
// non-par versions of the methods. this is why some of the code is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3835
// replicated. We should really get rid of the single-threaded version
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3836
// of the code to simplify things.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3837
void CMTask::drain_satb_buffers() {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3838
  if (has_aborted()) return;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3839
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3840
  // We set this so that the regular clock knows that we're in the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3841
  // middle of draining buffers and doesn't set the abort flag when it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3842
  // notices that SATB buffers are available for draining. It'd be
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3843
  // very counter productive if it did that. :-)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3844
  _draining_satb_buffers = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3845
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3846
  CMObjectClosure oc(this);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3847
  SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3848
  if (G1CollectedHeap::use_parallel_gc_threads()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3849
    satb_mq_set.set_par_closure(_worker_id, &oc);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3850
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3851
    satb_mq_set.set_closure(&oc);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3852
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3853
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3854
  // This keeps claiming and applying the closure to completed buffers
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3855
  // until we run out of buffers or we need to abort.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6261
diff changeset
  3856
  if (G1CollectedHeap::use_parallel_gc_threads()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3857
    while (!has_aborted() &&
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3858
           satb_mq_set.par_apply_closure_to_completed_buffer(_worker_id)) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3859
      if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3860
        gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3861
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3862
      statsOnly( ++_satb_buffers_processed );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3863
      regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3864
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3865
  } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3866
    while (!has_aborted() &&
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3867
           satb_mq_set.apply_closure_to_completed_buffer()) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3868
      if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3869
        gclog_or_tty->print_cr("[%u] processed an SATB buffer", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3870
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3871
      statsOnly( ++_satb_buffers_processed );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3872
      regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3873
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3874
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3875
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3876
  if (!concurrent() && !has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3877
    // We should only do this during remark.
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3878
    if (G1CollectedHeap::use_parallel_gc_threads()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3879
      satb_mq_set.par_iterate_closure_all_threads(_worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3880
    } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3881
      satb_mq_set.iterate_closure_all_threads();
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3882
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3883
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3884
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3885
  _draining_satb_buffers = false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3886
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3887
  assert(has_aborted() ||
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3888
         concurrent() ||
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  3889
         satb_mq_set.completed_buffers_num() == 0, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3890
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3891
  if (G1CollectedHeap::use_parallel_gc_threads()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3892
    satb_mq_set.set_par_closure(_worker_id, NULL);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3893
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3894
    satb_mq_set.set_closure(NULL);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  3895
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3896
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3897
  // again, this was a potentially expensive operation, decrease the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3898
  // limits to get the regular clock call early
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3899
  decrease_limits();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3900
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3901
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3902
void CMTask::print_stats() {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3903
  gclog_or_tty->print_cr("Marking Stats, task = %u, calls = %d",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  3904
                         _worker_id, _calls);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3905
  gclog_or_tty->print_cr("  Elapsed time = %1.2lfms, Termination time = %1.2lfms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3906
                         _elapsed_time_ms, _termination_time_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3907
  gclog_or_tty->print_cr("  Step Times (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3908
                         _step_times_ms.num(), _step_times_ms.avg(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3909
                         _step_times_ms.sd());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3910
  gclog_or_tty->print_cr("                    max = %1.2lfms, total = %1.2lfms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3911
                         _step_times_ms.maximum(), _step_times_ms.sum());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3912
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3913
#if _MARKING_STATS_
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3914
  gclog_or_tty->print_cr("  Clock Intervals (cum): num = %d, avg = %1.2lfms, sd = %1.2lfms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3915
                         _all_clock_intervals_ms.num(), _all_clock_intervals_ms.avg(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3916
                         _all_clock_intervals_ms.sd());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3917
  gclog_or_tty->print_cr("                         max = %1.2lfms, total = %1.2lfms",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3918
                         _all_clock_intervals_ms.maximum(),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3919
                         _all_clock_intervals_ms.sum());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3920
  gclog_or_tty->print_cr("  Clock Causes (cum): scanning = %d, marking = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3921
                         _clock_due_to_scanning, _clock_due_to_marking);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3922
  gclog_or_tty->print_cr("  Objects: scanned = %d, found on the bitmap = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3923
                         _objs_scanned, _objs_found_on_bitmap);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3924
  gclog_or_tty->print_cr("  Local Queue:  pushes = %d, pops = %d, max size = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3925
                         _local_pushes, _local_pops, _local_max_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3926
  gclog_or_tty->print_cr("  Global Stack: pushes = %d, pops = %d, max size = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3927
                         _global_pushes, _global_pops, _global_max_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3928
  gclog_or_tty->print_cr("                transfers to = %d, transfers from = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3929
                         _global_transfers_to,_global_transfers_from);
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3930
  gclog_or_tty->print_cr("  Regions: claimed = %d", _regions_claimed);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3931
  gclog_or_tty->print_cr("  SATB buffers: processed = %d", _satb_buffers_processed);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3932
  gclog_or_tty->print_cr("  Steals: attempts = %d, successes = %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3933
                         _steal_attempts, _steals);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3934
  gclog_or_tty->print_cr("  Aborted: %d, due to", _aborted);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3935
  gclog_or_tty->print_cr("    overflow: %d, global abort: %d, yield: %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3936
                         _aborted_overflow, _aborted_cm_aborted, _aborted_yield);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3937
  gclog_or_tty->print_cr("    time out: %d, SATB: %d, termination: %d",
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3938
                         _aborted_timed_out, _aborted_satb, _aborted_termination);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3939
#endif // _MARKING_STATS_
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3940
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3941
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3942
/*****************************************************************************
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3943
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  3944
    The do_marking_step(time_target_ms, ...) method is the building
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  3945
    block of the parallel marking framework. It can be called in parallel
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3946
    with other invocations of do_marking_step() on different tasks
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3947
    (but only one per task, obviously) and concurrently with the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3948
    mutator threads, or during remark, hence it eliminates the need
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3949
    for two versions of the code. When called during remark, it will
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3950
    pick up from where the task left off during the concurrent marking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3951
    phase. Interestingly, tasks are also claimable during evacuation
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3952
    pauses too, since do_marking_step() ensures that it aborts before
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3953
    it needs to yield.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3954
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  3955
    The data structures that it uses to do marking work are the
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3956
    following:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3957
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3958
      (1) Marking Bitmap. If there are gray objects that appear only
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3959
      on the bitmap (this happens either when dealing with an overflow
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3960
      or when the initial marking phase has simply marked the roots
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3961
      and didn't push them on the stack), then tasks claim heap
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3962
      regions whose bitmap they then scan to find gray objects. A
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3963
      global finger indicates where the end of the last claimed region
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3964
      is. A local finger indicates how far into the region a task has
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3965
      scanned. The two fingers are used to determine how to gray an
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3966
      object (i.e. whether simply marking it is OK, as it will be
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3967
      visited by a task in the future, or whether it needs to be also
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3968
      pushed on a stack).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3969
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3970
      (2) Local Queue. The local queue of the task which is accessed
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3971
      reasonably efficiently by the task. Other tasks can steal from
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3972
      it when they run out of work. Throughout the marking phase, a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3973
      task attempts to keep its local queue short but not totally
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3974
      empty, so that entries are available for stealing by other
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3975
      tasks. Only when there is no more work, a task will totally
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3976
      drain its local queue.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3977
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3978
      (3) Global Mark Stack. This handles local queue overflow. During
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3979
      marking only sets of entries are moved between it and the local
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3980
      queues, as access to it requires a mutex and more fine-grain
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3981
      interaction with it which might cause contention. If it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3982
      overflows, then the marking phase should restart and iterate
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3983
      over the bitmap to identify gray objects. Throughout the marking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3984
      phase, tasks attempt to keep the global mark stack at a small
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3985
      length but not totally empty, so that entries are available for
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3986
      popping by other tasks. Only when there is no more work, tasks
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3987
      will totally drain the global mark stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3988
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  3989
      (4) SATB Buffer Queue. This is where completed SATB buffers are
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3990
      made available. Buffers are regularly removed from this queue
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3991
      and scanned for roots, so that the queue doesn't get too
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3992
      long. During remark, all completed buffers are processed, as
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3993
      well as the filled in parts of any uncompleted buffers.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3994
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3995
    The do_marking_step() method tries to abort when the time target
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3996
    has been reached. There are a few other cases when the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3997
    do_marking_step() method also aborts:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3998
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  3999
      (1) When the marking phase has been aborted (after a Full GC).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4000
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4001
      (2) When a global overflow (on the global stack) has been
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4002
      triggered. Before the task aborts, it will actually sync up with
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4003
      the other tasks to ensure that all the marking data structures
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  4004
      (local queues, stacks, fingers etc.)  are re-initialized so that
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4005
      when do_marking_step() completes, the marking phase can
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4006
      immediately restart.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4007
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4008
      (3) When enough completed SATB buffers are available. The
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4009
      do_marking_step() method only tries to drain SATB buffers right
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4010
      at the beginning. So, if enough buffers are available, the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4011
      marking step aborts and the SATB buffers are processed at
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4012
      the beginning of the next invocation.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4013
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4014
      (4) To yield. when we have to yield then we abort and yield
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4015
      right at the end of do_marking_step(). This saves us from a lot
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4016
      of hassle as, by yielding we might allow a Full GC. If this
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4017
      happens then objects will be compacted underneath our feet, the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4018
      heap might shrink, etc. We save checking for this by just
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4019
      aborting and doing the yield right at the end.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4020
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4021
    From the above it follows that the do_marking_step() method should
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4022
    be called in a loop (or, otherwise, regularly) until it completes.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4023
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4024
    If a marking step completes without its has_aborted() flag being
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4025
    true, it means it has completed the current marking phase (and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4026
    also all other marking tasks have done so and have all synced up).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4027
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4028
    A method called regular_clock_call() is invoked "regularly" (in
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4029
    sub ms intervals) throughout marking. It is this clock method that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4030
    checks all the abort conditions which were mentioned above and
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4031
    decides when the task should abort. A work-based scheme is used to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4032
    trigger this clock method: when the number of object words the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4033
    marking phase has scanned or the number of references the marking
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4034
    phase has visited reach a given limit. Additional invocations to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4035
    the method clock have been planted in a few other strategic places
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4036
    too. The initial reason for the clock method was to avoid calling
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4037
    vtime too regularly, as it is quite expensive. So, once it was in
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4038
    place, it was natural to piggy-back all the other conditions on it
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4039
    too and not constantly check them throughout the code.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4040
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4041
    If do_termination is true then do_marking_step will enter its
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4042
    termination protocol.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4043
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4044
    The value of is_serial must be true when do_marking_step is being
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4045
    called serially (i.e. by the VMThread) and do_marking_step should
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4046
    skip any synchronization in the termination and overflow code.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4047
    Examples include the serial remark code and the serial reference
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4048
    processing closures.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4049
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4050
    The value of is_serial must be false when do_marking_step is
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4051
    being called by any of the worker threads in a work gang.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4052
    Examples include the concurrent marking code (CMMarkingTask),
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4053
    the MT remark code, and the MT reference processing closures.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4054
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4055
 *****************************************************************************/
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4056
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  4057
void CMTask::do_marking_step(double time_target_ms,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4058
                             bool do_termination,
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4059
                             bool is_serial) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4060
  assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4061
  assert(concurrent() == _cm->concurrent(), "they should be the same");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4062
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4063
  G1CollectorPolicy* g1_policy = _g1h->g1_policy();
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4064
  assert(_task_queues != NULL, "invariant");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4065
  assert(_task_queue != NULL, "invariant");
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4066
  assert(_task_queues->queue(_worker_id) == _task_queue, "invariant");
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4067
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4068
  assert(!_claimed,
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4069
         "only one thread should claim this task at any one time");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4070
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4071
  // OK, this doesn't safeguard again all possible scenarios, as it is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4072
  // possible for two threads to set the _claimed flag at the same
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4073
  // time. But it is only for debugging purposes anyway and it will
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4074
  // catch most problems.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4075
  _claimed = true;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4076
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4077
  _start_time_ms = os::elapsedVTime() * 1000.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4078
  statsOnly( _interval_start_time_ms = _start_time_ms );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4079
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4080
  // If do_stealing is true then do_marking_step will attempt to
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4081
  // steal work from the other CMTasks. It only makes sense to
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4082
  // enable stealing when the termination protocol is enabled
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4083
  // and do_marking_step() is not being called serially.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4084
  bool do_stealing = do_termination && !is_serial;
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4085
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4086
  double diff_prediction_ms =
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4087
    g1_policy->get_new_prediction(&_marking_step_diffs_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4088
  _time_target_ms = time_target_ms - diff_prediction_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4089
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4090
  // set up the variables that are used in the work-based scheme to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4091
  // call the regular clock method
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4092
  _words_scanned = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4093
  _refs_reached  = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4094
  recalculate_limits();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4095
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4096
  // clear all flags
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4097
  clear_has_aborted();
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  4098
  _has_timed_out = false;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4099
  _draining_satb_buffers = false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4100
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4101
  ++_calls;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4102
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4103
  if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4104
    gclog_or_tty->print_cr("[%u] >>>>>>>>>> START, call = %d, "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4105
                           "target = %1.2lfms >>>>>>>>>>",
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4106
                           _worker_id, _calls, _time_target_ms);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4107
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4108
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4109
  // Set up the bitmap and oop closures. Anything that uses them is
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4110
  // eventually called from this method, so it is OK to allocate these
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4111
  // statically.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4112
  CMBitMapClosure bitmap_closure(this, _cm, _nextMarkBitMap);
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  4113
  G1CMOopClosure  cm_oop_closure(_g1h, _cm, this);
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  4114
  set_cm_oop_closure(&cm_oop_closure);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4115
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4116
  if (_cm->has_overflown()) {
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4117
    // This can happen if the mark stack overflows during a GC pause
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4118
    // and this task, after a yield point, restarts. We have to abort
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4119
    // as we need to get into the overflow protocol which happens
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4120
    // right at the end of this task.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4121
    set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4122
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4123
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4124
  // First drain any available SATB buffers. After this, we will not
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4125
  // look at SATB buffers before the next invocation of this method.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4126
  // If enough completed SATB buffers are queued up, the regular clock
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4127
  // will abort this task so that it restarts.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4128
  drain_satb_buffers();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4129
  // ...then partially drain the local queue and the global stack
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4130
  drain_local_queue(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4131
  drain_global_stack(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4132
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4133
  do {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4134
    if (!has_aborted() && _curr_region != NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4135
      // This means that we're already holding on to a region.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4136
      assert(_finger != NULL, "if region is not NULL, then the finger "
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4137
             "should not be NULL either");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4138
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4139
      // We might have restarted this task after an evacuation pause
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4140
      // which might have evacuated the region we're holding on to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4141
      // underneath our feet. Let's read its limit again to make sure
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4142
      // that we do not iterate over a region of the heap that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4143
      // contains garbage (update_region_limit() will also move
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4144
      // _finger to the start of the region if it is found empty).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4145
      update_region_limit();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4146
      // We will start from _finger not from the start of the region,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4147
      // as we might be restarting this task after aborting half-way
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4148
      // through scanning this region. In this case, _finger points to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4149
      // the address where we last found a marked object. If this is a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4150
      // fresh region, _finger points to start().
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4151
      MemRegion mr = MemRegion(_finger, _region_limit);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4152
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4153
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4154
        gclog_or_tty->print_cr("[%u] we're scanning part "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4155
                               "["PTR_FORMAT", "PTR_FORMAT") "
15609
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4156
                               "of region "HR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4157
                               _worker_id, p2i(_finger), p2i(_region_limit),
15609
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4158
                               HR_FORMAT_PARAMS(_curr_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4159
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4160
15609
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4161
      assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4162
             "humongous regions should go around loop once only");
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4163
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4164
      // Some special cases:
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4165
      // If the memory region is empty, we can just give up the region.
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4166
      // If the current region is humongous then we only need to check
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4167
      // the bitmap for the bit associated with the start of the object,
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4168
      // scan the object if it's live, and give up the region.
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4169
      // Otherwise, let's iterate over the bitmap of the part of the region
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4170
      // that is left.
15604
0209977cd9c4 7052429: G1: Avoid unnecessary scanning of humongous regions during concurrent marking
johnc
parents: 15495
diff changeset
  4171
      // If the iteration is successful, give up the region.
15609
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4172
      if (mr.is_empty()) {
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4173
        giveup_current_region();
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4174
        regular_clock_call();
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4175
      } else if (_curr_region->isHumongous() && mr.start() == _curr_region->bottom()) {
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4176
        if (_nextMarkBitMap->isMarked(mr.start())) {
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4177
          // The object is marked - apply the closure
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4178
          BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start());
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4179
          bitmap_closure.do_bit(offset);
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4180
        }
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4181
        // Even if this task aborted while scanning the humongous object
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4182
        // we can (and should) give up the current region.
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4183
        giveup_current_region();
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4184
        regular_clock_call();
f2f53c966990 8007772: G1: assert(!hr->isHumongous() || mr.start() == hr->bottom()) failed: the start of HeapRegion and MemRegion should be consistent for humongous regions
johnc
parents: 15604
diff changeset
  4185
      } else if (_nextMarkBitMap->iterate(&bitmap_closure, mr)) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4186
        giveup_current_region();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4187
        regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4188
      } else {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4189
        assert(has_aborted(), "currently the only way to do so");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4190
        // The only way to abort the bitmap iteration is to return
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4191
        // false from the do_bit() method. However, inside the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4192
        // do_bit() method we move the _finger to point to the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4193
        // object currently being looked at. So, if we bail out, we
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4194
        // have definitely set _finger to something non-null.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4195
        assert(_finger != NULL, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4196
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4197
        // Region iteration was actually aborted. So now _finger
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4198
        // points to the address of the object we last scanned. If we
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4199
        // leave it there, when we restart this task, we will rescan
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4200
        // the object. It is easy to avoid this. We move the finger by
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4201
        // enough to point to the next possible object header (the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4202
        // bitmap knows by how much we need to move it as it knows its
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4203
        // granularity).
5079
c8e827e5dc2b 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 5035
diff changeset
  4204
        assert(_finger < _region_limit, "invariant");
15949
a55dea304e8c 8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
tamao
parents: 15609
diff changeset
  4205
        HeapWord* new_finger = _nextMarkBitMap->nextObject(_finger);
5079
c8e827e5dc2b 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 5035
diff changeset
  4206
        // Check if bitmap iteration was aborted while scanning the last object
c8e827e5dc2b 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 5035
diff changeset
  4207
        if (new_finger >= _region_limit) {
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4208
          giveup_current_region();
5079
c8e827e5dc2b 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 5035
diff changeset
  4209
        } else {
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4210
          move_finger_to(new_finger);
5079
c8e827e5dc2b 6921710: G1: assert(new_finger >= _finger && new_finger < _region_limit,"invariant")
apetrusenko
parents: 5035
diff changeset
  4211
        }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4212
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4213
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4214
    // At this point we have either completed iterating over the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4215
    // region we were holding on to, or we have aborted.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4216
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4217
    // We then partially drain the local queue and the global stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4218
    // (Do we really need this?)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4219
    drain_local_queue(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4220
    drain_global_stack(true);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4221
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4222
    // Read the note on the claim_region() method on why it might
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4223
    // return NULL with potentially more regions available for
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4224
    // claiming and why we have to check out_of_regions() to determine
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4225
    // whether we're done or not.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4226
    while (!has_aborted() && _curr_region == NULL && !_cm->out_of_regions()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4227
      // We are going to try to claim a new region. We should have
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4228
      // given up on the previous one.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4229
      // Separated the asserts so that we know which one fires.
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4230
      assert(_curr_region  == NULL, "invariant");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4231
      assert(_finger       == NULL, "invariant");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4232
      assert(_region_limit == NULL, "invariant");
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4233
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4234
        gclog_or_tty->print_cr("[%u] trying to claim a new region", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4235
      }
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4236
      HeapRegion* claimed_region = _cm->claim_region(_worker_id);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4237
      if (claimed_region != NULL) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4238
        // Yes, we managed to claim one
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4239
        statsOnly( ++_regions_claimed );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4240
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4241
        if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4242
          gclog_or_tty->print_cr("[%u] we successfully claimed "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4243
                                 "region "PTR_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4244
                                 _worker_id, p2i(claimed_region));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4245
        }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4246
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4247
        setup_for_region(claimed_region);
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4248
        assert(_curr_region == claimed_region, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4249
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4250
      // It is important to call the regular clock here. It might take
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4251
      // a while to claim a region if, for example, we hit a large
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4252
      // block of empty regions. So we need to call the regular clock
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4253
      // method once round the loop to make sure it's called
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4254
      // frequently enough.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4255
      regular_clock_call();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4256
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4257
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4258
    if (!has_aborted() && _curr_region == NULL) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4259
      assert(_cm->out_of_regions(),
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4260
             "at this point we should be out of regions");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4261
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4262
  } while ( _curr_region != NULL && !has_aborted());
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4263
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4264
  if (!has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4265
    // We cannot check whether the global stack is empty, since other
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4266
    // tasks might be pushing objects to it concurrently.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4267
    assert(_cm->out_of_regions(),
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4268
           "at this point we should be out of regions");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4269
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4270
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4271
      gclog_or_tty->print_cr("[%u] all regions claimed", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4272
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4273
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4274
    // Try to reduce the number of available SATB buffers so that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4275
    // remark has less work to do.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4276
    drain_satb_buffers();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4277
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4278
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4279
  // Since we've done everything else, we can now totally drain the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4280
  // local queue and global stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4281
  drain_local_queue(false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4282
  drain_global_stack(false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4283
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4284
  // Attempt at work stealing from other task's queues.
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  4285
  if (do_stealing && !has_aborted()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4286
    // We have not aborted. This means that we have finished all that
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4287
    // we could. Let's try to do some stealing...
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4288
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4289
    // We cannot check whether the global stack is empty, since other
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4290
    // tasks might be pushing objects to it concurrently.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4291
    assert(_cm->out_of_regions() && _task_queue->size() == 0,
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4292
           "only way to reach here");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4293
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4294
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4295
      gclog_or_tty->print_cr("[%u] starting to steal", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4296
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4297
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4298
    while (!has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4299
      oop obj;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4300
      statsOnly( ++_steal_attempts );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4301
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4302
      if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4303
        if (_cm->verbose_medium()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4304
          gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4305
                                 _worker_id, p2i((void*) obj));
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4306
        }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4307
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4308
        statsOnly( ++_steals );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4309
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4310
        assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4311
               "any stolen object should be marked");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4312
        scan_object(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4313
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4314
        // And since we're towards the end, let's totally drain the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4315
        // local queue and global stack.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4316
        drain_local_queue(false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4317
        drain_global_stack(false);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4318
      } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4319
        break;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4320
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4321
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4322
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4323
9417
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4324
  // If we are about to wrap up and go into termination, check if we
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4325
  // should raise the overflow flag.
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4326
  if (do_termination && !has_aborted()) {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4327
    if (_cm->force_overflow()->should_force()) {
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4328
      _cm->set_has_overflown();
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4329
      regular_clock_call();
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4330
    }
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4331
  }
6719a2e727c0 7034139: G1: assert(Thread::current()->is_ConcurrentGC_thread()) failed: only a conc GC thread can call this.
tonyp
parents: 8931
diff changeset
  4332
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4333
  // We still haven't aborted. Now, let's try to get into the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4334
  // termination protocol.
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  4335
  if (do_termination && !has_aborted()) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4336
    // We cannot check whether the global stack is empty, since other
12272
f87fd1292095 7127697: G1: remove dead code after recent concurrent mark changes
tonyp
parents: 11584
diff changeset
  4337
    // tasks might be concurrently pushing objects on it.
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4338
    // Separated the asserts so that we know which one fires.
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4339
    assert(_cm->out_of_regions(), "only way to reach here");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4340
    assert(_task_queue->size() == 0, "only way to reach here");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4341
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4342
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4343
      gclog_or_tty->print_cr("[%u] starting termination protocol", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4344
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4345
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4346
    _termination_start_time_ms = os::elapsedVTime() * 1000.0;
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4347
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4348
    // The CMTask class also extends the TerminatorTerminator class,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4349
    // hence its should_exit_termination() method will also decide
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4350
    // whether to exit the termination protocol or not.
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4351
    bool finished = (is_serial ||
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4352
                     _cm->terminator()->offer_termination(this));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4353
    double termination_end_time_ms = os::elapsedVTime() * 1000.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4354
    _termination_time_ms +=
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4355
      termination_end_time_ms - _termination_start_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4356
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4357
    if (finished) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4358
      // We're all done.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4359
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4360
      if (_worker_id == 0) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4361
        // let's allow task 0 to do this
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4362
        if (concurrent()) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4363
          assert(_cm->concurrent_marking_in_progress(), "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4364
          // we need to set this to false before the next
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4365
          // safepoint. This way we ensure that the marking phase
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4366
          // doesn't observe any more heap expansions.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4367
          _cm->clear_concurrent_marking_in_progress();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4368
        }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4369
      }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4370
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4371
      // We can now guarantee that the global stack is empty, since
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4372
      // all other tasks have finished. We separated the guarantees so
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4373
      // that, if a condition is false, we can immediately find out
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4374
      // which one.
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4375
      guarantee(_cm->out_of_regions(), "only way to reach here");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4376
      guarantee(_cm->mark_stack_empty(), "only way to reach here");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4377
      guarantee(_task_queue->size() == 0, "only way to reach here");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4378
      guarantee(!_cm->has_overflown(), "only way to reach here");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4379
      guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4380
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4381
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4382
        gclog_or_tty->print_cr("[%u] all tasks terminated", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4383
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4384
    } else {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4385
      // Apparently there's more work to do. Let's abort this task. It
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4386
      // will restart it and we can hopefully find more things to do.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4387
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4388
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4389
        gclog_or_tty->print_cr("[%u] apparently there is more work to do",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4390
                               _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4391
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4392
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4393
      set_has_aborted();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4394
      statsOnly( ++_aborted_termination );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4395
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4396
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4397
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4398
  // Mainly for debugging purposes to make sure that a pointer to the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4399
  // closure which was statically allocated in this frame doesn't
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4400
  // escape it by accident.
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  4401
  set_cm_oop_closure(NULL);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4402
  double end_time_ms = os::elapsedVTime() * 1000.0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4403
  double elapsed_time_ms = end_time_ms - _start_time_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4404
  // Update the step history.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4405
  _step_times_ms.add(elapsed_time_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4406
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4407
  if (has_aborted()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4408
    // The task was aborted for some reason.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4409
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4410
    statsOnly( ++_aborted );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4411
8073
a14dc27842dc 6608385: G1: need to support parallel reference processing
johnc
parents: 7923
diff changeset
  4412
    if (_has_timed_out) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4413
      double diff_ms = elapsed_time_ms - _time_target_ms;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4414
      // Keep statistics of how well we did with respect to hitting
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4415
      // our target only if we actually timed out (if we aborted for
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4416
      // other reasons, then the results might get skewed).
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4417
      _marking_step_diffs_ms.add(diff_ms);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4418
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4419
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4420
    if (_cm->has_overflown()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4421
      // This is the interesting one. We aborted because a global
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4422
      // overflow was raised. This means we have to restart the
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4423
      // marking phase and start iterating over regions. However, in
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4424
      // order to do this we have to make sure that all tasks stop
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  4425
      // what they are doing and re-initialize in a safe manner. We
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4426
      // will achieve this with the use of two barrier sync points.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4427
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4428
      if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4429
        gclog_or_tty->print_cr("[%u] detected overflow", _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4430
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4431
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4432
      if (!is_serial) {
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4433
        // We only need to enter the sync barrier if being called
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4434
        // from a parallel context
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4435
        _cm->enter_first_sync_barrier(_worker_id);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4436
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4437
        // When we exit this sync barrier we know that all tasks have
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4438
        // stopped doing marking work. So, it's now safe to
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22546
diff changeset
  4439
        // re-initialize our data structures. At the end of this method,
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4440
        // task 0 will clear the global data structures.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4441
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4442
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4443
      statsOnly( ++_aborted_overflow );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4444
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4445
      // We clear the local state of this task...
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4446
      clear_region_fields();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4447
16388
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4448
      if (!is_serial) {
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4449
        // ...and enter the second barrier.
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4450
        _cm->enter_second_sync_barrier(_worker_id);
60de0264afe8 8009536: G1: Apache Lucene hang during reference processing
johnc
parents: 15960
diff changeset
  4451
      }
16389
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  4452
      // At this point, if we're during the concurrent phase of
70f98431dd29 8009940: G1: assert(_finger == _heap_end) failed, concurrentMark.cpp:809
johnc
parents: 16388
diff changeset
  4453
      // marking, everything has been re-initialized and we're
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4454
      // ready to restart.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4455
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4456
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4457
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4458
      gclog_or_tty->print_cr("[%u] <<<<<<<<<< ABORTING, target = %1.2lfms, "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4459
                             "elapsed = %1.2lfms <<<<<<<<<<",
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4460
                             _worker_id, _time_target_ms, elapsed_time_ms);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4461
      if (_cm->has_aborted()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4462
        gclog_or_tty->print_cr("[%u] ========== MARKING ABORTED ==========",
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4463
                               _worker_id);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4464
      }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4465
    }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4466
  } else {
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4467
    if (_cm->verbose_low()) {
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4468
      gclog_or_tty->print_cr("[%u] <<<<<<<<<< FINISHED, target = %1.2lfms, "
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4469
                             "elapsed = %1.2lfms <<<<<<<<<<",
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4470
                             _worker_id, _time_target_ms, elapsed_time_ms);
9999
5f0b78217054 7055073: G1: code cleanup in the concurrentMark.* files
tonyp
parents: 9995
diff changeset
  4471
    }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4472
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4473
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4474
  _claimed = false;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4475
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4476
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4477
CMTask::CMTask(uint worker_id,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4478
               ConcurrentMark* cm,
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  4479
               size_t* marked_bytes,
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  4480
               BitMap* card_bm,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4481
               CMTaskQueue* task_queue,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4482
               CMTaskQueueSet* task_queues)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4483
  : _g1h(G1CollectedHeap::heap()),
14073
6012178c0c19 7127708: G1: change task num types from int to uint in concurrent mark
johnc
parents: 13919
diff changeset
  4484
    _worker_id(worker_id), _cm(cm),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4485
    _claimed(false),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4486
    _nextMarkBitMap(NULL), _hash_seed(17),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4487
    _task_queue(task_queue),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4488
    _task_queues(task_queues),
9994
efb74fdbd46e 7046558: G1: concurrent marking optimizations
tonyp
parents: 9936
diff changeset
  4489
    _cm_oop_closure(NULL),
11583
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  4490
    _marked_bytes_array(marked_bytes),
83a7383de44c 6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents: 11577
diff changeset
  4491
    _card_bm(card_bm) {
4026
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4492
  guarantee(task_queue != NULL, "invariant");
10386ea70fe5 6888619: G1: too many guarantees in concurrent marking
tonyp
parents: 4025
diff changeset
  4493
  guarantee(task_queues != NULL, "invariant");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4494
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4495
  statsOnly( _clock_due_to_scanning = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4496
             _clock_due_to_marking  = 0 );
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4497
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4498
  _marking_step_diffs_ms.add(0.5);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents:
diff changeset
  4499
}
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4500
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4501
// These are formatting macros that are used below to ensure
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4502
// consistent formatting. The *_H_* versions are used to format the
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4503
// header for a particular value and they should be kept consistent
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4504
// with the corresponding macro. Also note that most of the macros add
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4505
// the necessary white space (as a prefix) which makes them a bit
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4506
// easier to compose.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4507
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4508
// All the output lines are prefixed with this string to be able to
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4509
// identify them easily in a large log file.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4510
#define G1PPRL_LINE_PREFIX            "###"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4511
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4512
#define G1PPRL_ADDR_BASE_FORMAT    " "PTR_FORMAT"-"PTR_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4513
#ifdef _LP64
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4514
#define G1PPRL_ADDR_BASE_H_FORMAT  " %37s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4515
#else // _LP64
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4516
#define G1PPRL_ADDR_BASE_H_FORMAT  " %21s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4517
#endif // _LP64
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4518
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4519
// For per-region info
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4520
#define G1PPRL_TYPE_FORMAT            "   %-4s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4521
#define G1PPRL_TYPE_H_FORMAT          "   %4s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4522
#define G1PPRL_BYTE_FORMAT            "  "SIZE_FORMAT_W(9)
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4523
#define G1PPRL_BYTE_H_FORMAT          "  %9s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4524
#define G1PPRL_DOUBLE_FORMAT          "  %14.1f"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4525
#define G1PPRL_DOUBLE_H_FORMAT        "  %14s"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4526
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4527
// For summary info
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4528
#define G1PPRL_SUM_ADDR_FORMAT(tag)    "  "tag":"G1PPRL_ADDR_BASE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4529
#define G1PPRL_SUM_BYTE_FORMAT(tag)    "  "tag": "SIZE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4530
#define G1PPRL_SUM_MB_FORMAT(tag)      "  "tag": %1.2f MB"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4531
#define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag)" / %1.2f %%"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4532
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4533
G1PrintRegionLivenessInfoClosure::
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4534
G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name)
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4535
  : _out(out),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4536
    _total_used_bytes(0), _total_capacity_bytes(0),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4537
    _total_prev_live_bytes(0), _total_next_live_bytes(0),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4538
    _hum_used_bytes(0), _hum_capacity_bytes(0),
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4539
    _hum_prev_live_bytes(0), _hum_next_live_bytes(0),
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4540
    _total_remset_bytes(0), _total_strong_code_roots_bytes(0) {
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4541
  G1CollectedHeap* g1h = G1CollectedHeap::heap();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4542
  MemRegion g1_committed = g1h->g1_committed();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4543
  MemRegion g1_reserved = g1h->g1_reserved();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4544
  double now = os::elapsedTime();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4545
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4546
  // Print the header of the output.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4547
  _out->cr();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4548
  _out->print_cr(G1PPRL_LINE_PREFIX" PHASE %s @ %1.3f", phase_name, now);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4549
  _out->print_cr(G1PPRL_LINE_PREFIX" HEAP"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4550
                 G1PPRL_SUM_ADDR_FORMAT("committed")
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4551
                 G1PPRL_SUM_ADDR_FORMAT("reserved")
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4552
                 G1PPRL_SUM_BYTE_FORMAT("region-size"),
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4553
                 p2i(g1_committed.start()), p2i(g1_committed.end()),
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4554
                 p2i(g1_reserved.start()), p2i(g1_reserved.end()),
10677
370a8da2d63f 7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents: 10670
diff changeset
  4555
                 HeapRegion::GrainBytes);
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4556
  _out->print_cr(G1PPRL_LINE_PREFIX);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4557
  _out->print_cr(G1PPRL_LINE_PREFIX
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4558
                G1PPRL_TYPE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4559
                G1PPRL_ADDR_BASE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4560
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4561
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4562
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4563
                G1PPRL_DOUBLE_H_FORMAT
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4564
                G1PPRL_BYTE_H_FORMAT
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4565
                G1PPRL_BYTE_H_FORMAT,
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4566
                "type", "address-range",
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4567
                "used", "prev-live", "next-live", "gc-eff",
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4568
                "remset", "code-roots");
10668
1070b189c76e 7092245: G1: Wrong format specifier in G1PrintRegionLivenessInfo header output
johnc
parents: 10666
diff changeset
  4569
  _out->print_cr(G1PPRL_LINE_PREFIX
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4570
                G1PPRL_TYPE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4571
                G1PPRL_ADDR_BASE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4572
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4573
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4574
                G1PPRL_BYTE_H_FORMAT
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4575
                G1PPRL_DOUBLE_H_FORMAT
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4576
                G1PPRL_BYTE_H_FORMAT
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4577
                G1PPRL_BYTE_H_FORMAT,
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4578
                "", "",
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4579
                "(bytes)", "(bytes)", "(bytes)", "(bytes/ms)",
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4580
                "(bytes)", "(bytes)");
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4581
}
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4582
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4583
// It takes as a parameter a reference to one of the _hum_* fields, it
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4584
// deduces the corresponding value for a region in a humongous region
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4585
// series (either the region size, or what's left if the _hum_* field
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4586
// is < the region size), and updates the _hum_* field accordingly.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4587
size_t G1PrintRegionLivenessInfoClosure::get_hum_bytes(size_t* hum_bytes) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4588
  size_t bytes = 0;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4589
  // The > 0 check is to deal with the prev and next live bytes which
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4590
  // could be 0.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4591
  if (*hum_bytes > 0) {
10677
370a8da2d63f 7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents: 10670
diff changeset
  4592
    bytes = MIN2(HeapRegion::GrainBytes, *hum_bytes);
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4593
    *hum_bytes -= bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4594
  }
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4595
  return bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4596
}
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4597
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4598
// It deduces the values for a region in a humongous region series
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4599
// from the _hum_* fields and updates those accordingly. It assumes
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4600
// that that _hum_* fields have already been set up from the "starts
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4601
// humongous" region and we visit the regions in address order.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4602
void G1PrintRegionLivenessInfoClosure::get_hum_bytes(size_t* used_bytes,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4603
                                                     size_t* capacity_bytes,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4604
                                                     size_t* prev_live_bytes,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4605
                                                     size_t* next_live_bytes) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4606
  assert(_hum_used_bytes > 0 && _hum_capacity_bytes > 0, "pre-condition");
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4607
  *used_bytes      = get_hum_bytes(&_hum_used_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4608
  *capacity_bytes  = get_hum_bytes(&_hum_capacity_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4609
  *prev_live_bytes = get_hum_bytes(&_hum_prev_live_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4610
  *next_live_bytes = get_hum_bytes(&_hum_next_live_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4611
}
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4612
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4613
bool G1PrintRegionLivenessInfoClosure::doHeapRegion(HeapRegion* r) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4614
  const char* type = "";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4615
  HeapWord* bottom       = r->bottom();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4616
  HeapWord* end          = r->end();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4617
  size_t capacity_bytes  = r->capacity();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4618
  size_t used_bytes      = r->used();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4619
  size_t prev_live_bytes = r->live_bytes();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4620
  size_t next_live_bytes = r->next_live_bytes();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4621
  double gc_eff          = r->gc_efficiency();
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4622
  size_t remset_bytes    = r->rem_set()->mem_size();
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4623
  size_t strong_code_roots_bytes = r->rem_set()->strong_code_roots_mem_size();
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4624
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4625
  if (r->used() == 0) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4626
    type = "FREE";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4627
  } else if (r->is_survivor()) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4628
    type = "SURV";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4629
  } else if (r->is_young()) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4630
    type = "EDEN";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4631
  } else if (r->startsHumongous()) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4632
    type = "HUMS";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4633
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4634
    assert(_hum_used_bytes == 0 && _hum_capacity_bytes == 0 &&
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4635
           _hum_prev_live_bytes == 0 && _hum_next_live_bytes == 0,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4636
           "they should have been zeroed after the last time we used them");
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4637
    // Set up the _hum_* fields.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4638
    _hum_capacity_bytes  = capacity_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4639
    _hum_used_bytes      = used_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4640
    _hum_prev_live_bytes = prev_live_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4641
    _hum_next_live_bytes = next_live_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4642
    get_hum_bytes(&used_bytes, &capacity_bytes,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4643
                  &prev_live_bytes, &next_live_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4644
    end = bottom + HeapRegion::GrainWords;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4645
  } else if (r->continuesHumongous()) {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4646
    type = "HUMC";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4647
    get_hum_bytes(&used_bytes, &capacity_bytes,
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4648
                  &prev_live_bytes, &next_live_bytes);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4649
    assert(end == bottom + HeapRegion::GrainWords, "invariant");
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4650
  } else {
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4651
    type = "OLD";
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4652
  }
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4653
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4654
  _total_used_bytes      += used_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4655
  _total_capacity_bytes  += capacity_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4656
  _total_prev_live_bytes += prev_live_bytes;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4657
  _total_next_live_bytes += next_live_bytes;
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4658
  _total_remset_bytes    += remset_bytes;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4659
  _total_strong_code_roots_bytes += strong_code_roots_bytes;
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4660
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4661
  // Print a line for this particular region.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4662
  _out->print_cr(G1PPRL_LINE_PREFIX
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4663
                 G1PPRL_TYPE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4664
                 G1PPRL_ADDR_BASE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4665
                 G1PPRL_BYTE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4666
                 G1PPRL_BYTE_FORMAT
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4667
                 G1PPRL_BYTE_FORMAT
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4668
                 G1PPRL_DOUBLE_FORMAT
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4669
                 G1PPRL_BYTE_FORMAT
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4670
                 G1PPRL_BYTE_FORMAT,
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24244
diff changeset
  4671
                 type, p2i(bottom), p2i(end),
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4672
                 used_bytes, prev_live_bytes, next_live_bytes, gc_eff,
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4673
                 remset_bytes, strong_code_roots_bytes);
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4674
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4675
  return false;
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4676
}
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4677
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4678
G1PrintRegionLivenessInfoClosure::~G1PrintRegionLivenessInfoClosure() {
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4679
  // add static memory usages to remembered set sizes
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4680
  _total_remset_bytes += HeapRegionRemSet::fl_mem_size() + HeapRegionRemSet::static_mem_size();
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4681
  // Print the footer of the output.
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4682
  _out->print_cr(G1PPRL_LINE_PREFIX);
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4683
  _out->print_cr(G1PPRL_LINE_PREFIX
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4684
                 " SUMMARY"
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4685
                 G1PPRL_SUM_MB_FORMAT("capacity")
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4686
                 G1PPRL_SUM_MB_PERC_FORMAT("used")
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4687
                 G1PPRL_SUM_MB_PERC_FORMAT("prev-live")
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4688
                 G1PPRL_SUM_MB_PERC_FORMAT("next-live")
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4689
                 G1PPRL_SUM_MB_FORMAT("remset")
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4690
                 G1PPRL_SUM_MB_FORMAT("code-roots"),
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4691
                 bytes_to_mb(_total_capacity_bytes),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4692
                 bytes_to_mb(_total_used_bytes),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4693
                 perc(_total_used_bytes, _total_capacity_bytes),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4694
                 bytes_to_mb(_total_prev_live_bytes),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4695
                 perc(_total_prev_live_bytes, _total_capacity_bytes),
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4696
                 bytes_to_mb(_total_next_live_bytes),
17395
2cd3ef1be718 8014240: G1: Add remembered set size information to output of G1PrintRegionLivenessInfo
tschatzl
parents: 17112
diff changeset
  4697
                 perc(_total_next_live_bytes, _total_capacity_bytes),
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4698
                 bytes_to_mb(_total_remset_bytes),
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
  4699
                 bytes_to_mb(_total_strong_code_roots_bytes));
8930
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4700
  _out->cr();
52368505ee8e 7027766: G1: introduce flag to dump the liveness information per region at the end of marking
tonyp
parents: 8688
diff changeset
  4701
}