hotspot/src/share/vm/memory/referenceProcessor.hpp
author jmasa
Wed, 14 Dec 2011 13:34:57 -0800
changeset 11396 917d8673b5ef
parent 10747 dfdb9eb56e49
child 13195 be27e1b6a4b9
permissions -rw-r--r--
7121618: Change type of number of GC workers to unsigned int. Summary: Change variables representing the number of GC workers to uint from int and size_t. Change the parameter in work(int i) to work(uint worker_id). Reviewed-by: brutisso, tonyp
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: 4885
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4885
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: 4885
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: 6769
diff changeset
    25
#ifndef SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
    26
#define SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
    28
#include "memory/referencePolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
    29
#include "oops/instanceRefKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
    30
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// ReferenceProcessor class encapsulates the per-"collector" processing
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    32
// of java.lang.Reference objects for GC. The interface is useful for supporting
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// a generational abstraction, in particular when there are multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// generations that are being independently collected -- possibly
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// concurrently and/or incrementally.  Note, however, that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// ReferenceProcessor class abstracts away from a generational setting
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// by using only a heap interval (called "span" below), thus allowing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// its use in a straightforward manner in a general, non-generational
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// setting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// The basic idea is that each ReferenceProcessor object concerns
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// itself with ("weak") reference processing in a specific "span"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// of the heap of interest to a specific collector. Currently,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// the span is a convex interval of the heap, but, efficiency
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// apart, there seems to be no reason it couldn't be extended
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// (with appropriate modifications) to any "non-convex interval".
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// forward references
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
class ReferencePolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
class AbstractRefProcTaskExecutor;
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    51
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    52
// List of discovered references.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    53
class DiscoveredList {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    54
public:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    55
  DiscoveredList() : _len(0), _compressed_head(0), _oop_head(NULL) { }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    56
  oop head() const     {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    57
     return UseCompressedOops ?  oopDesc::decode_heap_oop(_compressed_head) :
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    58
                                _oop_head;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    59
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    60
  HeapWord* adr_head() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    61
    return UseCompressedOops ? (HeapWord*)&_compressed_head :
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    62
                               (HeapWord*)&_oop_head;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    63
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    64
  void set_head(oop o) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    65
    if (UseCompressedOops) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    66
      // Must compress the head ptr.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    67
      _compressed_head = oopDesc::encode_heap_oop(o);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    68
    } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    69
      _oop_head = o;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    70
    }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    71
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    72
  bool   is_empty() const       { return head() == NULL; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    73
  size_t length()               { return _len; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    74
  void   set_length(size_t len) { _len = len;  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    75
  void   inc_length(size_t inc) { _len += inc; assert(_len > 0, "Error"); }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    76
  void   dec_length(size_t dec) { _len -= dec; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    77
private:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    78
  // Set value depending on UseCompressedOops. This could be a template class
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    79
  // but then we have to fix all the instantiations and declarations that use this class.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    80
  oop       _oop_head;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    81
  narrowOop _compressed_head;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    82
  size_t _len;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    83
};
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    84
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    85
// Iterator for the list of discovered references.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    86
class DiscoveredListIterator {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    87
private:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    88
  DiscoveredList&    _refs_list;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    89
  HeapWord*          _prev_next;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    90
  oop                _prev;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    91
  oop                _ref;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    92
  HeapWord*          _discovered_addr;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    93
  oop                _next;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    94
  HeapWord*          _referent_addr;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    95
  oop                _referent;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    96
  OopClosure*        _keep_alive;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    97
  BoolObjectClosure* _is_alive;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    98
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
    99
  DEBUG_ONLY(
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   100
  oop                _first_seen; // cyclic linked list check
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   101
  )
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   102
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   103
  NOT_PRODUCT(
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   104
  size_t             _processed;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   105
  size_t             _removed;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   106
  )
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   107
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   108
public:
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   109
  inline DiscoveredListIterator(DiscoveredList&    refs_list,
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   110
                                OopClosure*        keep_alive,
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   111
                                BoolObjectClosure* is_alive):
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   112
    _refs_list(refs_list),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   113
    _prev_next(refs_list.adr_head()),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   114
    _prev(NULL),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   115
    _ref(refs_list.head()),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   116
#ifdef ASSERT
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   117
    _first_seen(refs_list.head()),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   118
#endif
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   119
#ifndef PRODUCT
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   120
    _processed(0),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   121
    _removed(0),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   122
#endif
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   123
    _next(NULL),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   124
    _keep_alive(keep_alive),
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   125
    _is_alive(is_alive)
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   126
{ }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   127
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   128
  // End Of List.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   129
  inline bool has_next() const { return _ref != NULL; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   130
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   131
  // Get oop to the Reference object.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   132
  inline oop obj() const { return _ref; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   133
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   134
  // Get oop to the referent object.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   135
  inline oop referent() const { return _referent; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   136
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   137
  // Returns true if referent is alive.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   138
  inline bool is_referent_alive() const {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   139
    return _is_alive->do_object_b(_referent);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   140
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   141
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   142
  // Loads data for the current reference.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   143
  // The "allow_null_referent" argument tells us to allow for the possibility
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   144
  // of a NULL referent in the discovered Reference object. This typically
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   145
  // happens in the case of concurrent collectors that may have done the
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   146
  // discovery concurrently, or interleaved, with mutator execution.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   147
  void load_ptrs(DEBUG_ONLY(bool allow_null_referent));
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   148
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   149
  // Move to the next discovered reference.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   150
  inline void next() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   151
    _prev_next = _discovered_addr;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   152
    _prev = _ref;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   153
    move_to_next();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   154
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   155
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   156
  // Remove the current reference from the list
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   157
  void remove();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   158
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   159
  // Make the Reference object active again.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   160
  void make_active();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   161
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   162
  // Make the referent alive.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   163
  inline void make_referent_alive() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   164
    if (UseCompressedOops) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   165
      _keep_alive->do_oop((narrowOop*)_referent_addr);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   166
    } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   167
      _keep_alive->do_oop((oop*)_referent_addr);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   168
    }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   169
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   170
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   171
  // Update the discovered field.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   172
  inline void update_discovered() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   173
    // First _prev_next ref actually points into DiscoveredList (gross).
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   174
    if (UseCompressedOops) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   175
      if (!oopDesc::is_null(*(narrowOop*)_prev_next)) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   176
        _keep_alive->do_oop((narrowOop*)_prev_next);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   177
      }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   178
    } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   179
      if (!oopDesc::is_null(*(oop*)_prev_next)) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   180
        _keep_alive->do_oop((oop*)_prev_next);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   181
      }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   182
    }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   183
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   184
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   185
  // NULL out referent pointer.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   186
  void clear_referent();
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   187
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   188
  // Statistics
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   189
  NOT_PRODUCT(
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   190
  inline size_t processed() const { return _processed; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   191
  inline size_t removed() const   { return _removed; }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   192
  )
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   193
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   194
  inline void move_to_next() {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   195
    if (_ref == _next) {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   196
      // End of the list.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   197
      _ref = NULL;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   198
    } else {
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   199
      _ref = _next;
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   200
    }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   201
    assert(_ref != _first_seen, "cyclic ref_list found");
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   202
    NOT_PRODUCT(_processed++);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   203
  }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   204
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
class ReferenceProcessor : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 protected:
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   208
  // Compatibility with pre-4965777 JDK's
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   209
  static bool _pending_list_uses_discovered_field;
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   210
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   211
  // The SoftReference master timestamp clock
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   212
  static jlong _soft_ref_timestamp_clock;
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   213
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   214
  MemRegion   _span;                    // (right-open) interval of heap
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   215
                                        // subject to wkref discovery
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   216
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   217
  bool        _discovering_refs;        // true when discovery enabled
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   218
  bool        _discovery_is_atomic;     // if discovery is atomic wrt
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   219
                                        // other collectors in configuration
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   220
  bool        _discovery_is_mt;         // true if reference discovery is MT.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   221
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   222
  // If true, setting "next" field of a discovered refs list requires
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   223
  // write barrier(s).  (Must be true if used in a collector in which
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   224
  // elements of a discovered list may be moved during discovery: for
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   225
  // example, a collector like Garbage-First that moves objects during a
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   226
  // long-term concurrent marking phase that does weak reference
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   227
  // discovery.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   228
  bool        _discovered_list_needs_barrier;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   230
  BarrierSet* _bs;                      // Cached copy of BarrierSet.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   231
  bool        _enqueuing_is_done;       // true if all weak references enqueued
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   232
  bool        _processing_is_mt;        // true during phases when
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   233
                                        // reference processing is MT.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   234
  uint        _next_id;                 // round-robin mod _num_q counter in
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   235
                                        // support of work distribution
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   236
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   237
  // For collectors that do not keep GC liveness information
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // in the object header, this field holds a closure that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // helps the reference processor determine the reachability
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   240
  // of an oop. It is currently initialized to NULL for all
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   241
  // collectors except for CMS and G1.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  BoolObjectClosure* _is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   244
  // Soft ref clearing policies
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   245
  // . the default policy
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   246
  static ReferencePolicy*   _default_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   247
  // . the "clear all" policy
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   248
  static ReferencePolicy*   _always_clear_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   249
  // . the current policy below is either one of the above
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   250
  ReferencePolicy*          _current_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   251
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  // The discovered ref lists themselves
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   253
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   254
  // The active MT'ness degree of the queues below
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   255
  uint             _num_q;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   256
  // The maximum MT'ness degree of the queues below
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   257
  uint             _max_num_q;
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   258
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   259
  // Master array of discovered oops
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   260
  DiscoveredList* _discovered_refs;
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   261
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   262
  // Arrays of lists of oops, one per thread (pointers into master array above)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   263
  DiscoveredList* _discoveredSoftRefs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  DiscoveredList* _discoveredWeakRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  DiscoveredList* _discoveredFinalRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  DiscoveredList* _discoveredPhantomRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
 public:
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   269
  static int number_of_subclasses_of_ref() { return (REF_PHANTOM - REF_OTHER); }
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   270
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   271
  uint num_q()                             { return _num_q; }
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   272
  uint max_num_q()                         { return _max_num_q; }
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   273
  void set_active_mt_degree(uint v)        { _num_q = v; }
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   274
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   275
  DiscoveredList* discovered_refs()        { return _discovered_refs; }
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   276
1610
5dddd195cc86 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 1606
diff changeset
   277
  ReferencePolicy* setup_policy(bool always_clear) {
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   278
    _current_soft_ref_policy = always_clear ?
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   279
      _always_clear_soft_ref_policy : _default_soft_ref_policy;
1610
5dddd195cc86 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 1606
diff changeset
   280
    _current_soft_ref_policy->setup();   // snapshot the policy threshold
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   281
    return _current_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   282
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // Process references with a certain reachability level.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  void process_discovered_reflist(DiscoveredList               refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
                                  ReferencePolicy*             policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
                                  bool                         clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
                                  BoolObjectClosure*           is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
                                  OopClosure*                  keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
                                  VoidClosure*                 complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
                                  AbstractRefProcTaskExecutor* task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  void process_phaseJNI(BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
                        OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
                        VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Work methods used by the method process_discovered_reflist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // Phase1: keep alive all those referents that are otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // dead but which must be kept alive by policy (and their closure).
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   300
  void process_phase1(DiscoveredList&     refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
                      ReferencePolicy*    policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
                      BoolObjectClosure*  is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
                      OopClosure*         keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
                      VoidClosure*        complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // Phase2: remove all those references whose referents are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // reachable.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   307
  inline void process_phase2(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
                             BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
                             OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
                             VoidClosure*       complete_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    if (discovery_is_atomic()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
      // complete_gc is ignored in this case for this phase
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   313
      pp2_work(refs_list, is_alive, keep_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
      assert(complete_gc != NULL, "Error");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   316
      pp2_work_concurrent_discovery(refs_list, is_alive,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
                                    keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // Work methods in support of process_phase2
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   321
  void pp2_work(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
                BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
                OopClosure*        keep_alive);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  void pp2_work_concurrent_discovery(
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   325
                DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
                BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
                OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
                VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // Phase3: process the referents by either clearing them
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // or keeping them alive (and their closure)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   331
  void process_phase3(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
                      bool               clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
                      BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
                      OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
                      VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // Enqueue references with a certain reachability level
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   338
  void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // "Preclean" all the discovered reference lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // by removing references with strongly reachable referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // The first argument is a predicate on an oop that indicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // its (strong) reachability and the second is a closure that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // may be used to incrementalize or abort the precleaning process.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // The caller is responsible for taking care of potential
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // interference with concurrent operations on these lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // (or predicates involved) by other threads. Currently
4738
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   348
  // only used by the CMS collector.  should_unload_classes is
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   349
  // used to aid assertion checking when classes are collected.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  void preclean_discovered_references(BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
                                      OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
                                      VoidClosure*       complete_gc,
4738
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   353
                                      YieldClosure*      yield,
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   354
                                      bool               should_unload_classes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // Delete entries in the discovered lists that have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  // either a null referent or are not active. Such
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  // Reference objects can result from the clearing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  // or enqueueing of Reference objects concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  // with their discovery by a (concurrent) collector.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  // For a definition of "active" see java.lang.ref.Reference;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // Refs are born active, become inactive when enqueued,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  // and never become active again. The state of being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // active is encoded as follows: A Ref is active
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  // if and only if its "next" field is NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  void clean_up_discovered_references();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  void clean_up_discovered_reflist(DiscoveredList& refs_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  // Returns the name of the discovered reference list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  // occupying the i / _num_q slot.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   371
  const char* list_name(uint i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   373
  void enqueue_discovered_reflists(HeapWord* pending_list_addr, AbstractRefProcTaskExecutor* task_executor);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   374
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
 protected:
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   376
  // Set the 'discovered' field of the given reference to
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   377
  // the given value - emitting barriers depending upon
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   378
  // the value of _discovered_list_needs_barrier.
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   379
  void set_discovered(oop ref, oop value);
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   380
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // "Preclean" the given discovered reference list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // by removing references with strongly reachable referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // Currently used in support of CMS only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  void preclean_discovered_reflist(DiscoveredList&    refs_list,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
                                   BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
                                   OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
                                   VoidClosure*       complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
                                   YieldClosure*      yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   390
  // round-robin mod _num_q (not: _not_ mode _max_num_q)
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   391
  uint next_id() {
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   392
    uint id = _next_id;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
    if (++_next_id == _num_q) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      _next_id = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    return id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  DiscoveredList* get_discovered_list(ReferenceType rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  inline void add_to_discovered_list_mt(DiscoveredList& refs_list, oop obj,
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   400
                                        HeapWord* discovered_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  void verify_ok_to_handle_reflists() PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
10524
6594ca81279a 7085906: Replace the permgen allocated sentinelRef with a self-looped end
stefank
parents: 8688
diff changeset
   403
  void clear_discovered_references(DiscoveredList& refs_list);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  void abandon_partial_discovered_list(DiscoveredList& refs_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  // Calculate the number of jni handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  unsigned int count_jni_refs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  // Balances reference queues.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  void balance_queues(DiscoveredList ref_lists[]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  // Update (advance) the soft ref master clock field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  void update_soft_ref_master_clock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  // constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  ReferenceProcessor():
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    _span((HeapWord*)NULL, (HeapWord*)NULL),
10747
dfdb9eb56e49 7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents: 10683
diff changeset
   419
    _discovered_refs(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    _discoveredSoftRefs(NULL),  _discoveredWeakRefs(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
    _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    _discovering_refs(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    _discovery_is_atomic(true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    _enqueuing_is_done(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    _discovery_is_mt(false),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   426
    _discovered_list_needs_barrier(false),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   427
    _bs(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    _is_alive_non_header(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    _num_q(0),
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   430
    _max_num_q(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
    _processing_is_mt(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
    _next_id(0)
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   433
  { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   435
  // Default parameters give you a vanilla reference processor.
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   436
  ReferenceProcessor(MemRegion span,
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   437
                     bool mt_processing = false, uint mt_processing_degree = 1,
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 10747
diff changeset
   438
                     bool mt_discovery  = false, uint mt_discovery_degree  = 1,
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   439
                     bool atomic_discovery = true,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   440
                     BoolObjectClosure* is_alive_non_header = NULL,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   441
                     bool discovered_list_needs_barrier = false);
4885
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   442
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // RefDiscoveryPolicy values
4885
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   444
  enum DiscoveryPolicy {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    ReferenceBasedDiscovery = 0,
4885
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   446
    ReferentBasedDiscovery  = 1,
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   447
    DiscoveryPolicyMin      = ReferenceBasedDiscovery,
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   448
    DiscoveryPolicyMax      = ReferentBasedDiscovery
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  static void init_statics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // get and set "is_alive_non_header" field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  BoolObjectClosure* is_alive_non_header() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
    return _is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
    _is_alive_non_header = is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // get and set span
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  MemRegion span()                   { return _span; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  void      set_span(MemRegion span) { _span = span; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  // start and stop weak ref discovery
10683
4b5a5a507864 7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
johnc
parents: 10670
diff changeset
   467
  void enable_discovery(bool verify_disabled, bool check_no_refs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  void disable_discovery()  { _discovering_refs = false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  bool discovery_enabled()  { return _discovering_refs;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // whether discovery is atomic wrt other collectors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  bool discovery_is_atomic() const { return _discovery_is_atomic; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
10526
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   475
  // whether the JDK in which we are embedded is a pre-4965777 JDK,
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   476
  // and thus whether or not it uses the discovered field to chain
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   477
  // the entries in the pending list.
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   478
  static bool pending_list_uses_discovered_field() {
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   479
    return _pending_list_uses_discovered_field;
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   480
  }
3e92f211533f 4965777: GC changes to support use of discovered field for pending references
ysr
parents: 10524
diff changeset
   481
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // whether discovery is done by multiple threads same-old-timeously
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  bool discovery_is_mt() const { return _discovery_is_mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  // Whether we are in a phase when _processing_ is MT.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  bool processing_is_mt() const { return _processing_is_mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  void set_mt_processing(bool mt) { _processing_is_mt = mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // whether all enqueuing of weak references is complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  bool enqueuing_is_done()  { return _enqueuing_is_done; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // iterate over oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  void weak_oops_do(OopClosure* f);       // weak roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   497
  // Balance each of the discovered lists.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   498
  void balance_all_queues();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   499
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // Discover a Reference object, using appropriate discovery criteria
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  bool discover_reference(oop obj, ReferenceType rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  // Process references found during GC (called by the garbage collector)
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   504
  void process_discovered_references(BoolObjectClosure*           is_alive,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
                                     OopClosure*                  keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
                                     VoidClosure*                 complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
                                     AbstractRefProcTaskExecutor* task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // Enqueue references at end of GC (called by the garbage collector)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   513
  // If a discovery is in process that is being superceded, abandon it: all
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   514
  // the discovered lists will be empty, and all the objects on them will
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   515
  // have NULL discovered fields.  Must be called only at a safepoint.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   516
  void abandon_partial_discovery();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   517
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  // debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  void verify_no_references_recorded() PRODUCT_RETURN;
7420
24071b15dde6 7005259: CMS: BubbleUpRef asserts referent(obj)->is_oop() failed: Enqueued a bad referent
ysr
parents: 7397
diff changeset
   520
  void verify_referent(oop obj)        PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // clear the discovered lists (unlinking each entry).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  void clear_discovered_references() PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
// A utility class to disable reference discovery in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
// the scope which contains it, for given ReferenceProcessor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
class NoRefDiscovery: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  bool _was_discovering_refs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  NoRefDiscovery(ReferenceProcessor* rp) : _rp(rp) {
6459
3d75ed40a975 6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents: 5547
diff changeset
   534
    _was_discovering_refs = _rp->discovery_enabled();
3d75ed40a975 6934483: GCC 4.5 errors "suggest parentheses around something..." when compiling with -Werror and -Wall
twisti
parents: 5547
diff changeset
   535
    if (_was_discovering_refs) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
      _rp->disable_discovery();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  ~NoRefDiscovery() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    if (_was_discovering_refs) {
10670
4ea0e7d2ffbc 6484982: G1: process references during evacuation pauses
johnc
parents: 10526
diff changeset
   542
      _rp->enable_discovery(true /*verify_disabled*/, false /*check_no_refs*/);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
// A utility class to temporarily mutate the span of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
class ReferenceProcessorSpanMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  MemRegion           _saved_span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
                                MemRegion span):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    _saved_span = _rp->span();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    _rp->set_span(span);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  ~ReferenceProcessorSpanMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    _rp->set_span(_saved_span);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
// A utility class to temporarily change the MT'ness of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
// reference discovery for the given ReferenceProcessor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
// in the scope that contains it.
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   571
class ReferenceProcessorMTDiscoveryMutator: StackObj {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  bool                _saved_mt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
 public:
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   577
  ReferenceProcessorMTDiscoveryMutator(ReferenceProcessor* rp,
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   578
                                       bool mt):
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    _saved_mt = _rp->discovery_is_mt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    _rp->set_mt_discovery(mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7420
diff changeset
   584
  ~ReferenceProcessorMTDiscoveryMutator() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    _rp->set_mt_discovery(_saved_mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
// A utility class to temporarily change the disposition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
// of the "is_alive_non_header" closure field of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
class ReferenceProcessorIsAliveMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  BoolObjectClosure*  _saved_cl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
                                   BoolObjectClosure*  cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    _saved_cl = _rp->is_alive_non_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    _rp->set_is_alive_non_header(cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  ~ReferenceProcessorIsAliveMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
    _rp->set_is_alive_non_header(_saved_cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
// A utility class to temporarily change the disposition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
// of the "discovery_is_atomic" field of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
class ReferenceProcessorAtomicMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  bool                _saved_atomic_discovery;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
                                  bool atomic):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    _saved_atomic_discovery = _rp->discovery_is_atomic();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    _rp->set_atomic_discovery(atomic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  ~ReferenceProcessorAtomicMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    _rp->set_atomic_discovery(_saved_atomic_discovery);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
// A utility class to temporarily change the MT processing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
// disposition of the given ReferenceProcessor instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
// in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
class ReferenceProcessorMTProcMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  bool  _saved_mt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
                                  bool mt):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    _saved_mt = _rp->processing_is_mt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    _rp->set_mt_processing(mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  ~ReferenceProcessorMTProcMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    _rp->set_mt_processing(_saved_mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// This class is an interface used to implement task execution for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
// reference processing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
class AbstractRefProcTaskExecutor {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  // Abstract tasks to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  class ProcessTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  class EnqueueTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  // Executes a task using worker threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  virtual void execute(ProcessTask& task) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  virtual void execute(EnqueueTask& task) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  // Switch to single threaded mode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  virtual void set_single_threaded_mode() { };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
// Abstract reference processing task to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
class AbstractRefProcTaskExecutor::ProcessTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  ProcessTask(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
              DiscoveredList      refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
              bool                marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    : _ref_processor(ref_processor),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
      _refs_lists(refs_lists),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
      _marks_oops_alive(marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
                    OopClosure& keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
                    VoidClosure& complete_gc) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  // Returns true if a task marks some oops as alive.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  bool marks_oops_alive() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  { return _marks_oops_alive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  ReferenceProcessor& _ref_processor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  DiscoveredList*     _refs_lists;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  const bool          _marks_oops_alive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
// Abstract reference processing task to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
class AbstractRefProcTaskExecutor::EnqueueTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  EnqueueTask(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
              DiscoveredList      refs_lists[],
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   703
              HeapWord*           pending_list_addr,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
              int                 n_queues)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    : _ref_processor(ref_processor),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      _refs_lists(refs_lists),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
      _pending_list_addr(pending_list_addr),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
      _n_queues(n_queues)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  virtual void work(unsigned int work_id) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  ReferenceProcessor& _ref_processor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  DiscoveredList*     _refs_lists;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   717
  HeapWord*           _pending_list_addr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  int                 _n_queues;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
   720
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6769
diff changeset
   721
#endif // SHARE_VM_MEMORY_REFERENCEPROCESSOR_HPP