hotspot/src/share/vm/memory/referenceProcessor.cpp
author tonyp
Tue, 08 Nov 2011 00:41:28 -0500
changeset 10997 0be4b3be7197
parent 10747 dfdb9eb56e49
child 11251 e29da6b5622b
permissions -rw-r--r--
7099849: G1: include heap region information in hs_err files Reviewed-by: johnc, brutisso, poonam
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
     2
 * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4738
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4738
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: 4738
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    26
#include "classfile/javaClasses.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    28
#include "gc_interface/collectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    29
#include "gc_interface/collectedHeap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    30
#include "memory/referencePolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    31
#include "memory/referenceProcessor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    32
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    33
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    34
#include "runtime/jniHandles.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    36
ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    37
ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy      = NULL;
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
    38
bool             ReferenceProcessor::_pending_list_uses_discovered_field = false;
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    39
jlong            ReferenceProcessor::_soft_ref_timestamp_clock = 0;
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
void referenceProcessor_init() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  ReferenceProcessor::init_statics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
void ReferenceProcessor::init_statics() {
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    46
  jlong now = os::javaTimeMillis();
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    47
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    48
  // Initialize the soft ref timestamp clock.
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    49
  _soft_ref_timestamp_clock = now;
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    50
  // Also update the soft ref clock in j.l.r.SoftReference
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    51
  java_lang_ref_SoftReference::set_clock(_soft_ref_timestamp_clock);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    53
  _always_clear_soft_ref_policy = new AlwaysClearPolicy();
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    54
  _default_soft_ref_policy      = new COMPILER2_PRESENT(LRUMaxHeapPolicy())
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    55
                                      NOT_COMPILER2(LRUCurrentHeapPolicy());
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    56
  if (_always_clear_soft_ref_policy == NULL || _default_soft_ref_policy == NULL) {
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    57
    vm_exit_during_initialization("Could not allocate reference policy object");
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
    58
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  guarantee(RefDiscoveryPolicy == ReferenceBasedDiscovery ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
            RefDiscoveryPolicy == ReferentBasedDiscovery,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
            "Unrecongnized RefDiscoveryPolicy");
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
    62
  _pending_list_uses_discovered_field = JDK_Version::current().pending_list_uses_discovered_field();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    65
void ReferenceProcessor::enable_discovery(bool verify_disabled, bool check_no_refs) {
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    66
#ifdef ASSERT
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    67
  // Verify that we're not currently discovering refs
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    68
  assert(!verify_disabled || !_discovering_refs, "nested call?");
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    69
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    70
  if (check_no_refs) {
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    71
    // Verify that the discovered lists are empty
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    72
    verify_no_references_recorded();
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    73
  }
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    74
#endif // ASSERT
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    75
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    76
  // Someone could have modified the value of the static
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    77
  // field in the j.l.r.SoftReference class that holds the
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    78
  // soft reference timestamp clock using reflection or
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    79
  // Unsafe between GCs. Unconditionally update the static
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    80
  // field in ReferenceProcessor here so that we use the new
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    81
  // value during reference discovery.
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    82
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    83
  _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    84
  _discovering_refs = true;
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    85
}
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
    86
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
ReferenceProcessor::ReferenceProcessor(MemRegion span,
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    88
                                       bool      mt_processing,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    89
                                       int       mt_processing_degree,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
    90
                                       bool      mt_discovery,
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    91
                                       int       mt_discovery_degree,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    92
                                       bool      atomic_discovery,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    93
                                       BoolObjectClosure* is_alive_non_header,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    94
                                       bool      discovered_list_needs_barrier)  :
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  _discovering_refs(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  _enqueuing_is_done(false),
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
    97
  _is_alive_non_header(is_alive_non_header),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    98
  _discovered_list_needs_barrier(discovered_list_needs_barrier),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    99
  _bs(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  _processing_is_mt(mt_processing),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  _next_id(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  _span = span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  _discovery_is_atomic = atomic_discovery;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  _discovery_is_mt     = mt_discovery;
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   106
  _num_q               = MAX2(1, mt_processing_degree);
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   107
  _max_num_q           = MAX2(_num_q, mt_discovery_degree);
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   108
  _discovered_refs     = NEW_C_HEAP_ARRAY(DiscoveredList,
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   109
                                          _max_num_q * number_of_subclasses_of_ref());
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   110
  if (_discovered_refs == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    vm_exit_during_initialization("Could not allocated RefProc Array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  }
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   113
  _discoveredSoftRefs    = &_discovered_refs[0];
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   114
  _discoveredWeakRefs    = &_discoveredSoftRefs[_max_num_q];
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   115
  _discoveredFinalRefs   = &_discoveredWeakRefs[_max_num_q];
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   116
  _discoveredPhantomRefs = &_discoveredFinalRefs[_max_num_q];
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   117
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   118
  // Initialize all entries to NULL
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   119
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   120
    _discovered_refs[i].set_head(NULL);
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   121
    _discovered_refs[i].set_length(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  }
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   123
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   124
  // If we do barriers, cache a copy of the barrier set.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   125
  if (discovered_list_needs_barrier) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   126
    _bs = Universe::heap()->barrier_set();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   127
  }
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   128
  setup_policy(false /* default soft ref policy */);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
void ReferenceProcessor::verify_no_references_recorded() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  guarantee(!_discovering_refs, "Discovering refs?");
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   134
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   135
    guarantee(_discovered_refs[i].is_empty(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
              "Found non-empty discovered list");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
void ReferenceProcessor::weak_oops_do(OopClosure* f) {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   142
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   143
    if (UseCompressedOops) {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   144
      f->do_oop((narrowOop*)_discovered_refs[i].adr_head());
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   145
    } else {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   146
      f->do_oop((oop*)_discovered_refs[i].adr_head());
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   147
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   151
void ReferenceProcessor::update_soft_ref_master_clock() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // Update (advance) the soft ref master clock field. This must be done
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // after processing the soft ref list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  jlong now = os::javaTimeMillis();
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   155
  jlong soft_ref_clock = java_lang_ref_SoftReference::clock();
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   156
  assert(soft_ref_clock == _soft_ref_timestamp_clock, "soft ref clocks out of sync");
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   157
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  NOT_PRODUCT(
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   159
  if (now < _soft_ref_timestamp_clock) {
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   160
    warning("time warp: "INT64_FORMAT" to "INT64_FORMAT,
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   161
            _soft_ref_timestamp_clock, now);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // In product mode, protect ourselves from system time being adjusted
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // externally and going backward; see note in the implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  // GenCollectedHeap::time_since_last_gc() for the right way to fix
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // this uniformly throughout the VM; see bug-id 4741166. XXX
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   168
  if (now > _soft_ref_timestamp_clock) {
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   169
    _soft_ref_timestamp_clock = now;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    java_lang_ref_SoftReference::set_clock(now);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // Else leave clock stalled at its old value until time progresses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // past clock value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   176
void ReferenceProcessor::process_discovered_references(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  BoolObjectClosure*           is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  OopClosure*                  keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  VoidClosure*                 complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  AbstractRefProcTaskExecutor* task_executor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  NOT_PRODUCT(verify_ok_to_handle_reflists());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  assert(!enqueuing_is_done(), "If here enqueuing should not be complete");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // Stop treating discovered references specially.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  disable_discovery();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   187
  // If discovery was concurrent, someone could have modified
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   188
  // the value of the static field in the j.l.r.SoftReference
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   189
  // class that holds the soft reference timestamp clock using
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   190
  // reflection or Unsafe between when discovery was enabled and
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   191
  // now. Unconditionally update the static field in ReferenceProcessor
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   192
  // here so that we use the new value during processing of the
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   193
  // discovered soft refs.
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   194
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   195
  _soft_ref_timestamp_clock = java_lang_ref_SoftReference::clock();
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   196
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  bool trace_time = PrintGCDetails && PrintReferenceGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // Soft references
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    TraceTime tt("SoftReference", trace_time, false, gclog_or_tty);
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
   201
    process_discovered_reflist(_discoveredSoftRefs, _current_soft_ref_policy, true,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
                               is_alive, keep_alive, complete_gc, task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  update_soft_ref_master_clock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  // Weak references
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    TraceTime tt("WeakReference", trace_time, false, gclog_or_tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    process_discovered_reflist(_discoveredWeakRefs, NULL, true,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
                               is_alive, keep_alive, complete_gc, task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  // Final references
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    TraceTime tt("FinalReference", trace_time, false, gclog_or_tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    process_discovered_reflist(_discoveredFinalRefs, NULL, false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
                               is_alive, keep_alive, complete_gc, task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // Phantom references
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    TraceTime tt("PhantomReference", trace_time, false, gclog_or_tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    process_discovered_reflist(_discoveredPhantomRefs, NULL, false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
                               is_alive, keep_alive, complete_gc, task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  // Weak global JNI references. It would make more sense (semantically) to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  // traverse these simultaneously with the regular weak references above, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  // that is not how the JDK1.2 specification is. See #4126360. Native code can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  // thus use JNI weak references to circumvent the phantom references and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  // resurrect a "post-mortem" object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    TraceTime tt("JNI Weak Reference", trace_time, false, gclog_or_tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    if (task_executor != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      task_executor->set_single_threaded_mode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
    process_phaseJNI(is_alive, keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
// Calculate the number of jni handles.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   244
uint ReferenceProcessor::count_jni_refs() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  class AlwaysAliveClosure: public BoolObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  public:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   247
    virtual bool do_object_b(oop obj) { return true; }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   248
    virtual void do_object(oop obj) { assert(false, "Don't call"); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  class CountHandleClosure: public OopClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
    int _count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    CountHandleClosure(): _count(0) {}
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   256
    void do_oop(oop* unused)       { _count++; }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   257
    void do_oop(narrowOop* unused) { ShouldNotReachHere(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
    int count() { return _count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  CountHandleClosure global_handle_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  AlwaysAliveClosure always_alive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  JNIHandles::weak_oops_do(&always_alive, &global_handle_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  return global_handle_count.count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
void ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
                                          OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
                                          VoidClosure*       complete_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  if (PrintGCDetails && PrintReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    unsigned int count = count_jni_refs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    gclog_or_tty->print(", %u refs", count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  JNIHandles::weak_oops_do(is_alive, keep_alive);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  complete_gc->do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   280
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   281
template <class T>
4493
9204129f065e 6843629: Make current hotspot build part of jdk5 control build
phh
parents: 3690
diff changeset
   282
bool enqueue_discovered_ref_helper(ReferenceProcessor* ref,
9204129f065e 6843629: Make current hotspot build part of jdk5 control build
phh
parents: 3690
diff changeset
   283
                                   AbstractRefProcTaskExecutor* task_executor) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   284
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  // Remember old value of pending references list
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   286
  T* pending_list_addr = (T*)java_lang_ref_Reference::pending_list_addr();
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   287
  T old_pending_list_value = *pending_list_addr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  // Enqueue references that are not made active again, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // clear the decks for the next collection (cycle).
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   291
  ref->enqueue_discovered_reflists((HeapWord*)pending_list_addr, task_executor);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // Do the oop-check on pending_list_addr missed in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // enqueue_discovered_reflist. We should probably
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // do a raw oop_check so that future such idempotent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // oop_stores relying on the oop-check side-effect
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  // may be elided automatically and safely without
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // affecting correctness.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   298
  oop_store(pending_list_addr, oopDesc::load_decode_heap_oop(pending_list_addr));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // Stop treating discovered references specially.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   301
  ref->disable_discovery();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // Return true if new pending references were added
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  return old_pending_list_value != *pending_list_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   307
bool ReferenceProcessor::enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   308
  NOT_PRODUCT(verify_ok_to_handle_reflists());
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   309
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   310
    return enqueue_discovered_ref_helper<narrowOop>(this, task_executor);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   311
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   312
    return enqueue_discovered_ref_helper<oop>(this, task_executor);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   313
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   314
}
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   315
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
void ReferenceProcessor::enqueue_discovered_reflist(DiscoveredList& refs_list,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   317
                                                    HeapWord* pending_list_addr) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // Given a list of refs linked through the "discovered" field
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   319
  // (java.lang.ref.Reference.discovered), self-loop their "next" field
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   320
  // thus distinguishing them from active References, then
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   321
  // prepend them to the pending list.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   322
  // BKWRD COMPATIBILITY NOTE: For older JDKs (prior to the fix for 4956777),
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   323
  // the "next" field is used to chain the pending list, not the discovered
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   324
  // field.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   325
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  if (TraceReferenceGC && PrintGCDetails) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
    gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
                           INTPTR_FORMAT, (address)refs_list.head());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  }
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   330
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   331
  oop obj = NULL;
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   332
  oop next_d = refs_list.head();
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   333
  if (pending_list_uses_discovered_field()) { // New behaviour
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   334
    // Walk down the list, self-looping the next field
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   335
    // so that the References are not considered active.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   336
    while (obj != next_d) {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   337
      obj = next_d;
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   338
      assert(obj->is_instanceRef(), "should be reference object");
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   339
      next_d = java_lang_ref_Reference::discovered(obj);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   340
      if (TraceReferenceGC && PrintGCDetails) {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   341
        gclog_or_tty->print_cr("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   342
                               obj, next_d);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   343
      }
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   344
      assert(java_lang_ref_Reference::next(obj) == NULL,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   345
             "Reference not active; should not be discovered");
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   346
      // Self-loop next, so as to make Ref not active.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   347
      java_lang_ref_Reference::set_next(obj, obj);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   348
      if (next_d == obj) {  // obj is last
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   349
        // Swap refs_list into pendling_list_addr and
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   350
        // set obj's discovered to what we read from pending_list_addr.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   351
        oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   352
        // Need oop_check on pending_list_addr above;
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   353
        // see special oop-check code at the end of
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   354
        // enqueue_discovered_reflists() further below.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   355
        java_lang_ref_Reference::set_discovered(obj, old); // old may be NULL
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   356
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    }
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   358
  } else { // Old behaviour
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   359
    // Walk down the list, copying the discovered field into
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   360
    // the next field and clearing the discovered field.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   361
    while (obj != next_d) {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   362
      obj = next_d;
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   363
      assert(obj->is_instanceRef(), "should be reference object");
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   364
      next_d = java_lang_ref_Reference::discovered(obj);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   365
      if (TraceReferenceGC && PrintGCDetails) {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   366
        gclog_or_tty->print_cr("        obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   367
                               obj, next_d);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   368
      }
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   369
      assert(java_lang_ref_Reference::next(obj) == NULL,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   370
             "The reference should not be enqueued");
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   371
      if (next_d == obj) {  // obj is last
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   372
        // Swap refs_list into pendling_list_addr and
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   373
        // set obj's next to what we read from pending_list_addr.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   374
        oop old = oopDesc::atomic_exchange_oop(refs_list.head(), pending_list_addr);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   375
        // Need oop_check on pending_list_addr above;
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   376
        // see special oop-check code at the end of
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   377
        // enqueue_discovered_reflists() further below.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   378
        if (old == NULL) {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   379
          // obj should be made to point to itself, since
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   380
          // pending list was empty.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   381
          java_lang_ref_Reference::set_next(obj, obj);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   382
        } else {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   383
          java_lang_ref_Reference::set_next(obj, old);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   384
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
      } else {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   386
        java_lang_ref_Reference::set_next(obj, next_d);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
      }
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   388
      java_lang_ref_Reference::set_discovered(obj, (oop) NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
// Parallel enqueue task
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
class RefProcEnqueueTask: public AbstractRefProcTaskExecutor::EnqueueTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  RefProcEnqueueTask(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
                     DiscoveredList      discovered_refs[],
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   398
                     HeapWord*           pending_list_addr,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
                     int                 n_queues)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    : EnqueueTask(ref_processor, discovered_refs,
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   401
                  pending_list_addr, n_queues)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   404
  virtual void work(unsigned int work_id) {
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   405
    assert(work_id < (unsigned int)_ref_processor.max_num_q(), "Index out-of-bounds");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    // Simplest first cut: static partitioning.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    int index = work_id;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   408
    // The increment on "index" must correspond to the maximum number of queues
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   409
    // (n_queues) with which that ReferenceProcessor was created.  That
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   410
    // is because of the "clever" way the discovered references lists were
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   411
    // allocated and are indexed into.
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   412
    assert(_n_queues == (int) _ref_processor.max_num_q(), "Different number not expected");
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   413
    for (int j = 0;
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   414
         j < ReferenceProcessor::number_of_subclasses_of_ref();
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   415
         j++, index += _n_queues) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
      _ref_processor.enqueue_discovered_reflist(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
        _refs_lists[index], _pending_list_addr);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   418
      _refs_lists[index].set_head(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
      _refs_lists[index].set_length(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
// Enqueue references that are not made active again
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   425
void ReferenceProcessor::enqueue_discovered_reflists(HeapWord* pending_list_addr,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  AbstractRefProcTaskExecutor* task_executor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  if (_processing_is_mt && task_executor != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    // Parallel code
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   429
    RefProcEnqueueTask tsk(*this, _discovered_refs,
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   430
                           pending_list_addr, _max_num_q);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
    task_executor->execute(tsk);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
    // Serial code: call the parent class's implementation
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   434
    for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   435
      enqueue_discovered_reflist(_discovered_refs[i], pending_list_addr);
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   436
      _discovered_refs[i].set_head(NULL);
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   437
      _discovered_refs[i].set_length(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   442
void DiscoveredListIterator::load_ptrs(DEBUG_ONLY(bool allow_null_referent)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  _discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   444
  oop discovered = java_lang_ref_Reference::discovered(_ref);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   445
  assert(_discovered_addr && discovered->is_oop_or_null(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
         "discovered field is bad");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   447
  _next = discovered;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  _referent_addr = java_lang_ref_Reference::referent_addr(_ref);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   449
  _referent = java_lang_ref_Reference::referent(_ref);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  assert(Universe::heap()->is_in_reserved_or_null(_referent),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
         "Wrong oop found in java.lang.Reference object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  assert(allow_null_referent ?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
             _referent->is_oop_or_null()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
           : _referent->is_oop(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
         "bad referent");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   458
void DiscoveredListIterator::remove() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  assert(_ref->is_oop(), "Dropping a bad reference");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   460
  oop_store_raw(_discovered_addr, NULL);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   461
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   462
  // First _prev_next ref actually points into DiscoveredList (gross).
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   463
  oop new_next;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   464
  if (_next == _ref) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   465
    // At the end of the list, we should make _prev point to itself.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   466
    // If _ref is the first ref, then _prev_next will be in the DiscoveredList,
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   467
    // and _prev will be NULL.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   468
    new_next = _prev;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   469
  } else {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   470
    new_next = _next;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   471
  }
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   472
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   473
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   474
    // Remove Reference object from list.
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   475
    oopDesc::encode_store_heap_oop((narrowOop*)_prev_next, new_next);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   476
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   477
    // Remove Reference object from list.
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   478
    oopDesc::store_heap_oop((oop*)_prev_next, new_next);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   479
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  NOT_PRODUCT(_removed++);
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   481
  _refs_list.dec_length(1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   484
// Make the Reference object active again.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   485
void DiscoveredListIterator::make_active() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   486
  // For G1 we don't want to use set_next - it
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   487
  // will dirty the card for the next field of
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   488
  // the reference object and will fail
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   489
  // CT verification.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   490
  if (UseG1GC) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   491
    BarrierSet* bs = oopDesc::bs();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   492
    HeapWord* next_addr = java_lang_ref_Reference::next_addr(_ref);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   493
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   494
    if (UseCompressedOops) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   495
      bs->write_ref_field_pre((narrowOop*)next_addr, NULL);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   496
    } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   497
      bs->write_ref_field_pre((oop*)next_addr, NULL);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   498
    }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   499
    java_lang_ref_Reference::set_next_raw(_ref, NULL);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   500
  } else {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   501
    java_lang_ref_Reference::set_next(_ref, NULL);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   502
  }
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   503
}
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   504
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   505
void DiscoveredListIterator::clear_referent() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   506
  oop_store_raw(_referent_addr, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
// NOTE: process_phase*() are largely similar, and at a high level
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
// merely iterate over the extant list applying a predicate to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
// each of its elements and possibly removing that element from the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
// list and applying some further closures to that element.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
// We should consider the possibility of replacing these
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
// process_phase*() methods by abstracting them into
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
// a single general iterator invocation that receives appropriate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
// closures that accomplish this work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
// (SoftReferences only) Traverse the list and remove any SoftReferences whose
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
// referents are not alive, but that should be kept alive for policy reasons.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
// Keep alive the transitive closure of all such referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
void
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   522
ReferenceProcessor::process_phase1(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
                                   ReferencePolicy*   policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
                                   BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
                                   OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
                                   VoidClosure*       complete_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  assert(policy != NULL, "Must have a non-NULL policy");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   528
  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // Decide which softly reachable refs should be kept alive.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    iter.load_ptrs(DEBUG_ONLY(!discovery_is_atomic() /* allow_null_referent */));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    bool referent_is_dead = (iter.referent() != NULL) && !iter.is_referent_alive();
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   533
    if (referent_is_dead &&
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   534
        !policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
      if (TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
        gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s"  ") by policy",
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   537
                               iter.obj(), iter.obj()->blueprint()->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
      }
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   539
      // Remove Reference object from list
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   540
      iter.remove();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
      // Make the Reference object active again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
      iter.make_active();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
      // keep the referent around
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
      iter.make_referent_alive();
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   545
      iter.move_to_next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // Close the reachable set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  complete_gc->do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  NOT_PRODUCT(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
    if (PrintGCDetails && TraceReferenceGC) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   554
      gclog_or_tty->print_cr(" Dropped %d dead Refs out of %d "
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   555
        "discovered Refs by policy, from list " INTPTR_FORMAT,
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   556
        iter.removed(), iter.processed(), (address)refs_list.head());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// Traverse the list and remove any Refs that are not active, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// whose referents are either alive or NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
void
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   564
ReferenceProcessor::pp2_work(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
                             BoolObjectClosure* is_alive,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   566
                             OopClosure*        keep_alive) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  assert(discovery_is_atomic(), "Error");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   568
  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   571
    DEBUG_ONLY(oop next = java_lang_ref_Reference::next(iter.obj());)
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   572
    assert(next == NULL, "Should not discover inactive Reference");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
    if (iter.is_referent_alive()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
      if (TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
        gclog_or_tty->print_cr("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)",
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   576
                               iter.obj(), iter.obj()->blueprint()->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
      // The referent is reachable after all.
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   579
      // Remove Reference object from list.
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   580
      iter.remove();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
      // Update the referent pointer as necessary: Note that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
      // should not entail any recursive marking because the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
      // referent must already have been traversed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
      iter.make_referent_alive();
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   585
      iter.move_to_next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  NOT_PRODUCT(
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   591
    if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   592
      gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   593
        "Refs in discovered list " INTPTR_FORMAT,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   594
        iter.removed(), iter.processed(), (address)refs_list.head());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
void
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   600
ReferenceProcessor::pp2_work_concurrent_discovery(DiscoveredList&    refs_list,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   601
                                                  BoolObjectClosure* is_alive,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   602
                                                  OopClosure*        keep_alive,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   603
                                                  VoidClosure*       complete_gc) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  assert(!discovery_is_atomic(), "Error");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   605
  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   608
    HeapWord* next_addr = java_lang_ref_Reference::next_addr(iter.obj());
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   609
    oop next = java_lang_ref_Reference::next(iter.obj());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
    if ((iter.referent() == NULL || iter.is_referent_alive() ||
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   611
         next != NULL)) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   612
      assert(next->is_oop_or_null(), "bad next field");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      // Remove Reference object from list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
      iter.remove();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
      // Trace the cohorts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
      iter.make_referent_alive();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   617
      if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   618
        keep_alive->do_oop((narrowOop*)next_addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   619
      } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   620
        keep_alive->do_oop((oop*)next_addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   621
      }
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   622
      iter.move_to_next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  // Now close the newly reachable set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  complete_gc->do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  NOT_PRODUCT(
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   630
    if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   631
      gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   632
        "Refs in discovered list " INTPTR_FORMAT,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   633
        iter.removed(), iter.processed(), (address)refs_list.head());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
// Traverse the list and process the referents, by either
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   639
// clearing them or keeping them (and their reachable
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
// closure) alive.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
void
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   642
ReferenceProcessor::process_phase3(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
                                   bool               clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
                                   BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
                                   OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
                                   VoidClosure*       complete_gc) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   647
  ResourceMark rm;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   648
  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    iter.update_discovered();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    if (clear_referent) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
      // NULL out referent pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
      iter.clear_referent();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
      // keep the referent around
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
      iter.make_referent_alive();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    if (TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
      gclog_or_tty->print_cr("Adding %sreference (" INTPTR_FORMAT ": %s) as pending",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
                             clear_referent ? "cleared " : "",
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   662
                             iter.obj(), iter.obj()->blueprint()->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    assert(iter.obj()->is_oop(UseConcMarkSweepGC), "Adding a bad reference");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
    iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  }
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   667
  // Remember to update the next pointer of the last ref.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  iter.update_discovered();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  // Close the reachable set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  complete_gc->do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
void
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   674
ReferenceProcessor::clear_discovered_references(DiscoveredList& refs_list) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   675
  oop obj = NULL;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   676
  oop next = refs_list.head();
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   677
  while (next != obj) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   678
    obj = next;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   679
    next = java_lang_ref_Reference::discovered(obj);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   680
    java_lang_ref_Reference::set_discovered_raw(obj, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  }
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   682
  refs_list.set_head(NULL);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   683
  refs_list.set_length(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   686
void
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   687
ReferenceProcessor::abandon_partial_discovered_list(DiscoveredList& refs_list) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   688
  clear_discovered_references(refs_list);
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   689
}
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   690
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   691
void ReferenceProcessor::abandon_partial_discovery() {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   692
  // loop over the lists
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   693
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   694
    if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   695
      gclog_or_tty->print_cr("\nAbandoning %s discovered list", list_name(i));
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   696
    }
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   697
    abandon_partial_discovered_list(_discovered_refs[i]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
class RefProcPhase1Task: public AbstractRefProcTaskExecutor::ProcessTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  RefProcPhase1Task(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
                    DiscoveredList      refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
                    ReferencePolicy*    policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
                    bool                marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
      _policy(policy)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  virtual void work(unsigned int i, BoolObjectClosure& is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
                    OopClosure& keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
                    VoidClosure& complete_gc)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   714
    Thread* thr = Thread::current();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   715
    int refs_list_index = ((WorkerThread*)thr)->id();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   716
    _ref_processor.process_phase1(_refs_lists[refs_list_index], _policy,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
                                  &is_alive, &keep_alive, &complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  ReferencePolicy* _policy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
class RefProcPhase2Task: public AbstractRefProcTaskExecutor::ProcessTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  RefProcPhase2Task(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
                    DiscoveredList      refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
                    bool                marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
    : ProcessTask(ref_processor, refs_lists, marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  virtual void work(unsigned int i, BoolObjectClosure& is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
                    OopClosure& keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
                    VoidClosure& complete_gc)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
    _ref_processor.process_phase2(_refs_lists[i],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
                                  &is_alive, &keep_alive, &complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
class RefProcPhase3Task: public AbstractRefProcTaskExecutor::ProcessTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  RefProcPhase3Task(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
                    DiscoveredList      refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
                    bool                clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
                    bool                marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    : ProcessTask(ref_processor, refs_lists, marks_oops_alive),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
      _clear_referent(clear_referent)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  virtual void work(unsigned int i, BoolObjectClosure& is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
                    OopClosure& keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
                    VoidClosure& complete_gc)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   752
    // Don't use "refs_list_index" calculated in this way because
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   753
    // balance_queues() has moved the Ref's into the first n queues.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   754
    // Thread* thr = Thread::current();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   755
    // int refs_list_index = ((WorkerThread*)thr)->id();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   756
    // _ref_processor.process_phase3(_refs_lists[refs_list_index], _clear_referent,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    _ref_processor.process_phase3(_refs_lists[i], _clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
                                  &is_alive, &keep_alive, &complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  bool _clear_referent;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   764
void ReferenceProcessor::set_discovered(oop ref, oop value) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   765
  if (_discovered_list_needs_barrier) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   766
    java_lang_ref_Reference::set_discovered(ref, value);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   767
  } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   768
    java_lang_ref_Reference::set_discovered_raw(ref, value);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   769
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   770
}
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   771
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
// Balances reference queues.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   773
// Move entries from all queues[0, 1, ..., _max_num_q-1] to
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   774
// queues[0, 1, ..., _num_q-1] because only the first _num_q
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   775
// corresponding to the active workers will be processed.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
void ReferenceProcessor::balance_queues(DiscoveredList ref_lists[])
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  // calculate total length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  size_t total_refs = 0;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   780
  if (TraceReferenceGC && PrintGCDetails) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   781
    gclog_or_tty->print_cr("\nBalance ref_lists ");
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   782
  }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   783
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   784
  for (int i = 0; i < _max_num_q; ++i) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
    total_refs += ref_lists[i].length();
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   786
    if (TraceReferenceGC && PrintGCDetails) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   787
      gclog_or_tty->print("%d ", ref_lists[i].length());
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   788
    }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   789
  }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   790
  if (TraceReferenceGC && PrintGCDetails) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   791
    gclog_or_tty->print_cr(" = %d", total_refs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  size_t avg_refs = total_refs / _num_q + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  int to_idx = 0;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   795
  for (int from_idx = 0; from_idx < _max_num_q; from_idx++) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   796
    bool move_all = false;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   797
    if (from_idx >= _num_q) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   798
      move_all = ref_lists[from_idx].length() > 0;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   799
    }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   800
    while ((ref_lists[from_idx].length() > avg_refs) ||
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   801
           move_all) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      assert(to_idx < _num_q, "Sanity Check!");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
      if (ref_lists[to_idx].length() < avg_refs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
        // move superfluous refs
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   805
        size_t refs_to_move;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   806
        // Move all the Ref's if the from queue will not be processed.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   807
        if (move_all) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   808
          refs_to_move = MIN2(ref_lists[from_idx].length(),
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   809
                              avg_refs - ref_lists[to_idx].length());
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   810
        } else {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   811
          refs_to_move = MIN2(ref_lists[from_idx].length() - avg_refs,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   812
                              avg_refs - ref_lists[to_idx].length());
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   813
        }
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   814
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   815
        assert(refs_to_move > 0, "otherwise the code below will fail");
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   816
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
        oop move_head = ref_lists[from_idx].head();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
        oop move_tail = move_head;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
        oop new_head  = move_head;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
        // find an element to split the list on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
        for (size_t j = 0; j < refs_to_move; ++j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
          move_tail = new_head;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   823
          new_head = java_lang_ref_Reference::discovered(new_head);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
        }
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   825
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   826
        // Add the chain to the to list.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   827
        if (ref_lists[to_idx].head() == NULL) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   828
          // to list is empty. Make a loop at the end.
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   829
          set_discovered(move_tail, move_tail);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   830
        } else {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   831
          set_discovered(move_tail, ref_lists[to_idx].head());
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   832
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
        ref_lists[to_idx].set_head(move_head);
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   834
        ref_lists[to_idx].inc_length(refs_to_move);
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   835
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   836
        // Remove the chain from the from list.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   837
        if (move_tail == new_head) {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   838
          // We found the end of the from list.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   839
          ref_lists[from_idx].set_head(NULL);
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   840
        } else {
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   841
          ref_lists[from_idx].set_head(new_head);
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   842
        }
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   843
        ref_lists[from_idx].dec_length(refs_to_move);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   844
        if (ref_lists[from_idx].length() == 0) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   845
          break;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   846
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
      } else {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   848
        to_idx = (to_idx + 1) % _num_q;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   852
#ifdef ASSERT
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   853
  size_t balanced_total_refs = 0;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   854
  for (int i = 0; i < _max_num_q; ++i) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   855
    balanced_total_refs += ref_lists[i].length();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   856
    if (TraceReferenceGC && PrintGCDetails) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   857
      gclog_or_tty->print("%d ", ref_lists[i].length());
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   858
    }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   859
  }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   860
  if (TraceReferenceGC && PrintGCDetails) {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   861
    gclog_or_tty->print_cr(" = %d", balanced_total_refs);
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   862
    gclog_or_tty->flush();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   863
  }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   864
  assert(total_refs == balanced_total_refs, "Balancing was incomplete");
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   865
#endif
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   866
}
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   867
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   868
void ReferenceProcessor::balance_all_queues() {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   869
  balance_queues(_discoveredSoftRefs);
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   870
  balance_queues(_discoveredWeakRefs);
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   871
  balance_queues(_discoveredFinalRefs);
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   872
  balance_queues(_discoveredPhantomRefs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
ReferenceProcessor::process_discovered_reflist(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  DiscoveredList               refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  ReferencePolicy*             policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  bool                         clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  BoolObjectClosure*           is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  OopClosure*                  keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  VoidClosure*                 complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  AbstractRefProcTaskExecutor* task_executor)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
{
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   885
  bool mt_processing = task_executor != NULL && _processing_is_mt;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   886
  // If discovery used MT and a dynamic number of GC threads, then
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   887
  // the queues must be balanced for correctness if fewer than the
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   888
  // maximum number of queues were used.  The number of queue used
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   889
  // during discovery may be different than the number to be used
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   890
  // for processing so don't depend of _num_q < _max_num_q as part
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   891
  // of the test.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   892
  bool must_balance = _discovery_is_mt;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   893
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   894
  if ((mt_processing && ParallelRefProcBalancingEnabled) ||
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   895
      must_balance) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
    balance_queues(refs_lists);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  if (PrintReferenceGC && PrintGCDetails) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    size_t total = 0;
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   900
    for (int i = 0; i < _max_num_q; ++i) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
      total += refs_lists[i].length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
    gclog_or_tty->print(", %u refs", total);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  // Phase 1 (soft refs only):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  // . Traverse the list and remove any SoftReferences whose
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  //   referents are not alive, but that should be kept alive for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  //   policy reasons. Keep alive the transitive closure of all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  //   such referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  if (policy != NULL) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   912
    if (mt_processing) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
      RefProcPhase1Task phase1(*this, refs_lists, policy, true /*marks_oops_alive*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
      task_executor->execute(phase1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
    } else {
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   916
      for (int i = 0; i < _max_num_q; i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
        process_phase1(refs_lists[i], policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
                       is_alive, keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  } else { // policy == NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
    assert(refs_lists != _discoveredSoftRefs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
           "Policy must be specified for soft references.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
  // Phase 2:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  // . Traverse the list and remove any refs whose referents are alive.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   928
  if (mt_processing) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
    RefProcPhase2Task phase2(*this, refs_lists, !discovery_is_atomic() /*marks_oops_alive*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
    task_executor->execute(phase2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  } else {
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   932
    for (int i = 0; i < _max_num_q; i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
      process_phase2(refs_lists[i], is_alive, keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  // Phase 3:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  // . Traverse the list and process referents as appropriate.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   939
  if (mt_processing) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
    RefProcPhase3Task phase3(*this, refs_lists, clear_referent, true /*marks_oops_alive*/);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
    task_executor->execute(phase3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  } else {
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   943
    for (int i = 0; i < _max_num_q; i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
      process_phase3(refs_lists[i], clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
                     is_alive, keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
void ReferenceProcessor::clean_up_discovered_references() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  // loop over the lists
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   952
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   953
    if (TraceReferenceGC && PrintGCDetails && ((i % _max_num_q) == 0)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
      gclog_or_tty->print_cr(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
        "\nScrubbing %s discovered list of Null referents",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
        list_name(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    }
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   958
    clean_up_discovered_reflist(_discovered_refs[i]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
void ReferenceProcessor::clean_up_discovered_reflist(DiscoveredList& refs_list) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  assert(!discovery_is_atomic(), "Else why call this method?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  DiscoveredListIterator iter(refs_list, NULL, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
    iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   967
    oop next = java_lang_ref_Reference::next(iter.obj());
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   968
    assert(next->is_oop_or_null(), "bad next field");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
    // If referent has been cleared or Reference is not active,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
    // drop it.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   971
    if (iter.referent() == NULL || next != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
      debug_only(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
        if (PrintGCDetails && TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
          gclog_or_tty->print_cr("clean_up_discovered_list: Dropping Reference: "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
            INTPTR_FORMAT " with next field: " INTPTR_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
            " and referent: " INTPTR_FORMAT,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
   977
            iter.obj(), next, iter.referent());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
      )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
      // Remove Reference object from list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
      iter.remove();
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   982
      iter.move_to_next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  NOT_PRODUCT(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    if (PrintGCDetails && TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
      gclog_or_tty->print(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
        " Removed %d Refs with NULL referents out of %d discovered Refs",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
        iter.removed(), iter.processed());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
inline DiscoveredList* ReferenceProcessor::get_discovered_list(ReferenceType rt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  int id = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  // Determine the queue index to use for this object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  if (_discovery_is_mt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    // During a multi-threaded discovery phase,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
    // each thread saves to its "own" list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    Thread* thr = Thread::current();
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1003
    id = thr->as_Worker_thread()->id();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    // single-threaded discovery, we save in round-robin
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
    // fashion to each of the lists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    if (_processing_is_mt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
      id = next_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1011
  assert(0 <= id && id < _max_num_q, "Id is out-of-bounds (call Freud?)");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  // Get the discovered queue to which we will add
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  DiscoveredList* list = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  switch (rt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
    case REF_OTHER:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
      // Unknown reference type, no special treatment
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
    case REF_SOFT:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
      list = &_discoveredSoftRefs[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
    case REF_WEAK:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
      list = &_discoveredWeakRefs[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
    case REF_FINAL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
      list = &_discoveredFinalRefs[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
    case REF_PHANTOM:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
      list = &_discoveredPhantomRefs[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    case REF_NONE:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
      // we should not reach here if we are an instanceRefKlass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
      ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1036
  if (TraceReferenceGC && PrintGCDetails) {
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1037
    gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, list);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1038
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  return list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1042
inline void
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1043
ReferenceProcessor::add_to_discovered_list_mt(DiscoveredList& refs_list,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1044
                                              oop             obj,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1045
                                              HeapWord*       discovered_addr) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  assert(_discovery_is_mt, "!_discovery_is_mt should have been handled by caller");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // First we must make sure this object is only enqueued once. CAS in a non null
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  // discovered_addr.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1049
  oop current_head = refs_list.head();
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1050
  // The last ref must have its discovered field pointing to itself.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1051
  oop next_discovered = (current_head != NULL) ? current_head : obj;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1052
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2105
diff changeset
  1053
  // Note: In the case of G1, this specific pre-barrier is strictly
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1054
  // not necessary because the only case we are interested in
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2105
diff changeset
  1055
  // here is when *discovered_addr is NULL (see the CAS further below),
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2105
diff changeset
  1056
  // so this will expand to nothing. As a result, we have manually
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 2105
diff changeset
  1057
  // elided this out for G1, but left in the test for some future
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1058
  // collector that might have need for a pre-barrier here, e.g.:-
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1059
  // _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1060
  assert(!_discovered_list_needs_barrier || UseG1GC,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1061
         "Need to check non-G1 collector: "
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1062
         "may need a pre-write-barrier for CAS from NULL below");
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1063
  oop retest = oopDesc::atomic_compare_exchange_oop(next_discovered, discovered_addr,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1064
                                                    NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  if (retest == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
    // This thread just won the right to enqueue the object.
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1067
    // We have separate lists for enqueueing, so no synchronization
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
    // is necessary.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1069
    refs_list.set_head(obj);
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1070
    refs_list.inc_length(1);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1071
    if (_discovered_list_needs_barrier) {
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1072
      _bs->write_ref_field((void*)discovered_addr, next_discovered);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1073
    }
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1074
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1075
    if (TraceReferenceGC) {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1076
      gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1077
                             obj, obj->blueprint()->internal_name());
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1078
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
    // If retest was non NULL, another thread beat us to it:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
    // The reference has already been discovered...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
    if (TraceReferenceGC) {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1083
      gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
                             obj, obj->blueprint()->internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1089
#ifndef PRODUCT
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1090
// Non-atomic (i.e. concurrent) discovery might allow us
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1091
// to observe j.l.References with NULL referents, being those
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1092
// cleared concurrently by mutators during (or after) discovery.
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1093
void ReferenceProcessor::verify_referent(oop obj) {
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1094
  bool da = discovery_is_atomic();
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1095
  oop referent = java_lang_ref_Reference::referent(obj);
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1096
  assert(da ? referent->is_oop() : referent->is_oop_or_null(),
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1097
         err_msg("Bad referent " INTPTR_FORMAT " found in Reference "
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1098
                 INTPTR_FORMAT " during %satomic discovery ",
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1099
                 (intptr_t)referent, (intptr_t)obj, da ? "" : "non-"));
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1100
}
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1101
#endif
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1102
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
// We mention two of several possible choices here:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
// #0: if the reference object is not in the "originating generation"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
//     (or part of the heap being collected, indicated by our "span"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
//     we don't treat it specially (i.e. we scan it as we would
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
//     a normal oop, treating its references as strong references).
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1108
//     This means that references can't be discovered unless their
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
//     referent is also in the same span. This is the simplest,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
//     most "local" and most conservative approach, albeit one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
//     that may cause weak references to be enqueued least promptly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
//     We call this choice the "ReferenceBasedDiscovery" policy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
// #1: the reference object may be in any generation (span), but if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
//     the referent is in the generation (span) being currently collected
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
//     then we can discover the reference object, provided
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
//     the object has not already been discovered by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
//     a different concurrently running collector (as may be the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
//     case, for instance, if the reference object is in CMS and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
//     the referent in DefNewGeneration), and provided the processing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
//     of this reference object by the current collector will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
//     appear atomic to every other collector in the system.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
//     (Thus, for instance, a concurrent collector may not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
//     discover references in other generations even if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
//     referent is in its own generation). This policy may,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
//     in certain cases, enqueue references somewhat sooner than
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
//     might Policy #0 above, but at marginally increased cost
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
//     and complexity in processing these references.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
//     We call this choice the "RefeferentBasedDiscovery" policy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
bool ReferenceProcessor::discover_reference(oop obj, ReferenceType rt) {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1130
  // Make sure we are discovering refs (rather than processing discovered refs).
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  if (!_discovering_refs || !RegisterReferences) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  }
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1134
  // We only discover active references.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1135
  oop next = java_lang_ref_Reference::next(obj);
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1136
  if (next != NULL) {   // Ref is no longer active
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  HeapWord* obj_addr = (HeapWord*)obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  if (RefDiscoveryPolicy == ReferenceBasedDiscovery &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
      !_span.contains(obj_addr)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
    // Reference is not in the originating generation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
    // don't treat it specially (i.e. we want to scan it as a normal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
    // object with strong references).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1149
  // We only discover references whose referents are not (yet)
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1150
  // known to be strongly reachable.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  if (is_alive_non_header() != NULL) {
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1152
    verify_referent(obj);
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1153
    if (is_alive_non_header()->do_object_b(java_lang_ref_Reference::referent(obj))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
      return false;  // referent is reachable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  }
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1157
  if (rt == REF_SOFT) {
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1158
    // For soft refs we can decide now if these are not
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1159
    // current candidates for clearing, in which case we
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1160
    // can mark through them now, rather than delaying that
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1161
    // to the reference-processing phase. Since all current
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1162
    // time-stamp policies advance the soft-ref clock only
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1163
    // at a major collection cycle, this is always currently
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1164
    // accurate.
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
  1165
    if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) {
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1166
      return false;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1167
    }
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1605
diff changeset
  1168
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1170
  ResourceMark rm;      // Needed for tracing.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1171
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1172
  HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1173
  const oop  discovered = java_lang_ref_Reference::discovered(obj);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1174
  assert(discovered->is_oop_or_null(), "bad discovered field");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1175
  if (discovered != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
    // The reference has already been discovered...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
    if (TraceReferenceGC) {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1178
      gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1179
                             obj, obj->blueprint()->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
    if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
      // assumes that an object is not processed twice;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
      // if it's been already discovered it must be on another
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
      // generation's discovered list; so we won't discover it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
      assert(RefDiscoveryPolicy == ReferenceBasedDiscovery,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
             "Unrecognized policy");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
      // Check assumption that an object is not potentially
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
      // discovered twice except by concurrent collectors that potentially
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
      // trace the same Reference object twice.
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1192
      assert(UseConcMarkSweepGC || UseG1GC,
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1193
             "Only possible with a concurrent marking collector");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1199
    verify_referent(obj);
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1200
    // Discover if and only if EITHER:
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1201
    // .. reference is in our span, OR
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1202
    // .. we are an atomic collector and referent is in our span
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
    if (_span.contains(obj_addr) ||
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1204
        (discovery_is_atomic() &&
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1205
         _span.contains(java_lang_ref_Reference::referent(obj)))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
      // should_enqueue = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
    assert(RefDiscoveryPolicy == ReferenceBasedDiscovery &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
           _span.contains(obj_addr), "code inconsistency");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  // Get the right type of discovered queue head.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  DiscoveredList* list = get_discovered_list(rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  if (list == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    return false;   // nothing special needs to be done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  if (_discovery_is_mt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    add_to_discovered_list_mt(*list, obj, discovered_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  } else {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1224
    // If "_discovered_list_needs_barrier", we do write barriers when
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1225
    // updating the discovered reference list.  Otherwise, we do a raw store
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1226
    // here: the field will be visited later when processing the discovered
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1227
    // references.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1228
    oop current_head = list->head();
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1229
    // The last ref must have its discovered field pointing to itself.
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1230
    oop next_discovered = (current_head != NULL) ? current_head : obj;
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1231
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1232
    // As in the case further above, since we are over-writing a NULL
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1233
    // pre-value, we can safely elide the pre-barrier here for the case of G1.
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1234
    // e.g.:- _bs->write_ref_field_pre((oop* or narrowOop*)discovered_addr, next_discovered);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1235
    assert(discovered == NULL, "control point invariant");
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1236
    assert(!_discovered_list_needs_barrier || UseG1GC,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1237
           "For non-G1 collector, may need a pre-write-barrier for CAS from NULL below");
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1238
    oop_store_raw(discovered_addr, next_discovered);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1239
    if (_discovered_list_needs_barrier) {
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1240
      _bs->write_ref_field((void*)discovered_addr, next_discovered);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
  1241
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
    list->set_head(obj);
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1243
    list->inc_length(1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1245
    if (TraceReferenceGC) {
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1246
      gclog_or_tty->print_cr("Discovered reference (" INTPTR_FORMAT ": %s)",
7399
4ecd771fa2d1 6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents: 7397
diff changeset
  1247
                                obj, obj->blueprint()->internal_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
  }
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
  1250
  assert(obj->is_oop(), "Discovered a bad reference");
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7399
diff changeset
  1251
  verify_referent(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
// Preclean the discovered references by removing those
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
// whose referents are alive, and by marking from those that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
// are not active. These lists can be handled here
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
// in any order and, indeed, concurrently.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
void ReferenceProcessor::preclean_discovered_references(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  OopClosure* keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
  VoidClosure* complete_gc,
4738
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 4573
diff changeset
  1263
  YieldClosure* yield,
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 4573
diff changeset
  1264
  bool should_unload_classes) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
  NOT_PRODUCT(verify_ok_to_handle_reflists());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
3690
dba50b88bd50 6798898: CMS: bugs related to class unloading
jmasa
parents: 3262
diff changeset
  1268
#ifdef ASSERT
dba50b88bd50 6798898: CMS: bugs related to class unloading
jmasa
parents: 3262
diff changeset
  1269
  bool must_remember_klasses = ClassUnloading && !UseConcMarkSweepGC ||
4738
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 4573
diff changeset
  1270
                               CMSClassUnloadingEnabled && UseConcMarkSweepGC ||
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 4573
diff changeset
  1271
                               ExplicitGCInvokesConcurrentAndUnloadsClasses &&
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 4573
diff changeset
  1272
                                 UseConcMarkSweepGC && should_unload_classes;
3690
dba50b88bd50 6798898: CMS: bugs related to class unloading
jmasa
parents: 3262
diff changeset
  1273
  RememberKlassesChecker mx(must_remember_klasses);
dba50b88bd50 6798898: CMS: bugs related to class unloading
jmasa
parents: 3262
diff changeset
  1274
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  // Soft references
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
    TraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
              false, gclog_or_tty);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1279
    for (int i = 0; i < _max_num_q; i++) {
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1280
      if (yield->should_return()) {
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1281
        return;
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1282
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
      preclean_discovered_reflist(_discoveredSoftRefs[i], is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
                                  keep_alive, complete_gc, yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
  // Weak references
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    TraceTime tt("Preclean WeakReferences", PrintGCDetails && PrintReferenceGC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
              false, gclog_or_tty);
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
  1292
    for (int i = 0; i < _max_num_q; i++) {
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1293
      if (yield->should_return()) {
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1294
        return;
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1295
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
      preclean_discovered_reflist(_discoveredWeakRefs[i], is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
                                  keep_alive, complete_gc, yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
  // Final references
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
    TraceTime tt("Preclean FinalReferences", PrintGCDetails && PrintReferenceGC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
              false, gclog_or_tty);
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
  1305
    for (int i = 0; i < _max_num_q; i++) {
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1306
      if (yield->should_return()) {
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1307
        return;
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1308
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
      preclean_discovered_reflist(_discoveredFinalRefs[i], is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
                                  keep_alive, complete_gc, yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  // Phantom references
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    TraceTime tt("Preclean PhantomReferences", PrintGCDetails && PrintReferenceGC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
              false, gclog_or_tty);
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
  1318
    for (int i = 0; i < _max_num_q; i++) {
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1319
      if (yield->should_return()) {
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1320
        return;
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1321
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
      preclean_discovered_reflist(_discoveredPhantomRefs[i], is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
                                  keep_alive, complete_gc, yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
// Walk the given discovered ref list, and remove all reference objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
// whose referents are still alive, whose referents are NULL or which
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1330
// are not active (have a non-NULL next field). NOTE: When we are
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1331
// thus precleaning the ref lists (which happens single-threaded today),
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1332
// we do not disable refs discovery to honour the correct semantics of
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1333
// java.lang.Reference. As a result, we need to be careful below
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1334
// that ref removal steps interleave safely with ref discovery steps
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1335
// (in this thread).
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1336
void
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1337
ReferenceProcessor::preclean_discovered_reflist(DiscoveredList&    refs_list,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1338
                                                BoolObjectClosure* is_alive,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1339
                                                OopClosure*        keep_alive,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1340
                                                VoidClosure*       complete_gc,
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1341
                                                YieldClosure*      yield) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  while (iter.has_next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
    iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1345
    oop obj = iter.obj();
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1346
    oop next = java_lang_ref_Reference::next(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
    if (iter.referent() == NULL || iter.is_referent_alive() ||
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1348
        next != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
      // The referent has been cleared, or is alive, or the Reference is not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
      // active; we need to trace and mark its cohort.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
      if (TraceReferenceGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
        gclog_or_tty->print_cr("Precleaning Reference (" INTPTR_FORMAT ": %s)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
                               iter.obj(), iter.obj()->blueprint()->internal_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
      // Remove Reference object from list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
      iter.remove();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
      // Keep alive its cohort.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
      iter.make_referent_alive();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1359
      if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1360
        narrowOop* next_addr = (narrowOop*)java_lang_ref_Reference::next_addr(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1361
        keep_alive->do_oop(next_addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1362
      } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1363
        oop* next_addr = (oop*)java_lang_ref_Reference::next_addr(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1364
        keep_alive->do_oop(next_addr);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 178
diff changeset
  1365
      }
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1366
      iter.move_to_next();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
      iter.next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  // Close the reachable set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
  complete_gc->do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  NOT_PRODUCT(
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
  1375
    if (PrintGCDetails && PrintReferenceGC && (iter.processed() > 0)) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1376
      gclog_or_tty->print_cr(" Dropped %d Refs out of %d "
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1377
        "Refs in discovered list " INTPTR_FORMAT,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1378
        iter.removed(), iter.processed(), (address)refs_list.head());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
const char* ReferenceProcessor::list_name(int i) {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1384
   assert(i >= 0 && i <= _max_num_q * number_of_subclasses_of_ref(),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1385
          "Out of bounds index");
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1386
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
  1387
   int j = i / _max_num_q;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
   switch (j) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
     case 0: return "SoftRef";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
     case 1: return "WeakRef";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
     case 2: return "FinalRef";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
     case 3: return "PhantomRef";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
   ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
   return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
void ReferenceProcessor::verify_ok_to_handle_reflists() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
  // empty for now
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
void ReferenceProcessor::clear_discovered_references() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  guarantee(!_discovering_refs, "Discovering refs?");
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
  1407
  for (int i = 0; i < _max_num_q * number_of_subclasses_of_ref(); i++) {
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
  1408
    clear_discovered_references(_discovered_refs[i]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
}
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
  1411
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
#endif // PRODUCT