hotspot/src/share/vm/memory/referenceProcessor.hpp
author jcoomes
Fri, 08 Oct 2010 09:29:09 -0700
changeset 6769 5f30b5a1ce5c
parent 6459 3d75ed40a975
parent 6759 67b1a69ef5aa
child 7397 5b173b4ca846
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
     2
 * Copyright (c) 2001, 2010, 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
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
// ReferenceProcessor class encapsulates the per-"collector" processing
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    26
// of java.lang.Reference objects for GC. The interface is useful for supporting
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
// a generational abstraction, in particular when there are multiple
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// generations that are being independently collected -- possibly
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
// concurrently and/or incrementally.  Note, however, that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// ReferenceProcessor class abstracts away from a generational setting
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// by using only a heap interval (called "span" below), thus allowing
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// its use in a straightforward manner in a general, non-generational
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// setting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// The basic idea is that each ReferenceProcessor object concerns
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// itself with ("weak") reference processing in a specific "span"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// of the heap of interest to a specific collector. Currently,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// the span is a convex interval of the heap, but, efficiency
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// apart, there seems to be no reason it couldn't be extended
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// (with appropriate modifications) to any "non-convex interval".
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// forward references
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class ReferencePolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
class AbstractRefProcTaskExecutor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class DiscoveredList;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
class ReferenceProcessor : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  // End of list marker
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  static oop  _sentinelRef;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  MemRegion   _span; // (right-open) interval of heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
                     // subject to wkref discovery
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  bool        _discovering_refs;      // true when discovery enabled
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  bool        _discovery_is_atomic;   // if discovery is atomic wrt
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
                                      // other collectors in configuration
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  bool        _discovery_is_mt;       // true if reference discovery is MT.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    57
  // 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
    58
  // 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
    59
  // 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
    60
  // 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
    61
  // long-term concurrent marking phase that does weak reference
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    62
  // discovery.)
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    63
  bool        _discovered_list_needs_barrier;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    64
  BarrierSet* _bs;                    // Cached copy of BarrierSet.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  bool        _enqueuing_is_done;     // true if all weak references enqueued
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  bool        _processing_is_mt;      // true during phases when
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
                                      // reference processing is MT.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  int         _next_id;               // round-robin counter in
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
                                      // support of work distribution
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // For collectors that do not keep GC marking information
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // in the object header, this field holds a closure that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // helps the reference processor determine the reachability
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  // of an oop (the field is currently initialized to NULL for
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  // all collectors but the CMS collector).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  BoolObjectClosure* _is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    78
  // Soft ref clearing policies
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    79
  // . the default policy
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    80
  static ReferencePolicy*   _default_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    81
  // . the "clear all" policy
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    82
  static ReferencePolicy*   _always_clear_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    83
  // . the current policy below is either one of the above
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    84
  ReferencePolicy*          _current_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
    85
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  // 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
    87
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    88
  // The active MT'ness degree of the queues below
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    89
  int             _num_q;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    90
  // The maximum MT'ness degree of the queues below
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    91
  int             _max_num_q;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    92
  // Arrays of lists of oops, one per thread
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    93
  DiscoveredList* _discoveredSoftRefs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  DiscoveredList* _discoveredWeakRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  DiscoveredList* _discoveredFinalRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  DiscoveredList* _discoveredPhantomRefs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
 public:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    99
  int num_q()                            { return _num_q; }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   100
  void set_mt_degree(int v)              { _num_q = v; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  DiscoveredList* discovered_soft_refs() { return _discoveredSoftRefs; }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   102
  static oop  sentinel_ref()             { return _sentinelRef; }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   103
  static oop* adr_sentinel_ref()         { return &_sentinelRef; }
1610
5dddd195cc86 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 1606
diff changeset
   104
  ReferencePolicy* setup_policy(bool always_clear) {
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   105
    _current_soft_ref_policy = always_clear ?
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   106
      _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
   107
    _current_soft_ref_policy->setup();   // snapshot the policy threshold
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   108
    return _current_soft_ref_policy;
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1388
diff changeset
   109
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  // Process references with a certain reachability level.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  void process_discovered_reflist(DiscoveredList               refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
                                  ReferencePolicy*             policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                                  bool                         clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                                  BoolObjectClosure*           is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
                                  OopClosure*                  keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
                                  VoidClosure*                 complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
                                  AbstractRefProcTaskExecutor* task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  void process_phaseJNI(BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
                        OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
                        VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // Work methods used by the method process_discovered_reflist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // Phase1: keep alive all those referents that are otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // 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
   128
  void process_phase1(DiscoveredList&     refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
                      ReferencePolicy*    policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
                      BoolObjectClosure*  is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
                      OopClosure*         keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
                      VoidClosure*        complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // Phase2: remove all those references whose referents are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  // reachable.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   135
  inline void process_phase2(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
                             BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
                             OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
                             VoidClosure*       complete_gc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    if (discovery_is_atomic()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
      // 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
   141
      pp2_work(refs_list, is_alive, keep_alive);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
      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
   144
      pp2_work_concurrent_discovery(refs_list, is_alive,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
                                    keep_alive, complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // 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
   149
  void pp2_work(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
                BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
                OopClosure*        keep_alive);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  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
   153
                DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
                BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
                OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
                VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Phase3: process the referents by either clearing them
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // 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
   159
  void process_phase3(DiscoveredList&    refs_list,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
                      bool               clear_referent,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
                      BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
                      OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
                      VoidClosure*       complete_gc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // 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
   166
  void enqueue_discovered_reflist(DiscoveredList& refs_list, HeapWord* pending_list_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // "Preclean" all the discovered reference lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // by removing references with strongly reachable referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // The first argument is a predicate on an oop that indicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // its (strong) reachability and the second is a closure that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // may be used to incrementalize or abort the precleaning process.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // The caller is responsible for taking care of potential
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // interference with concurrent operations on these lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // (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
   176
  // 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
   177
  // used to aid assertion checking when classes are collected.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  void preclean_discovered_references(BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
                                      OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
                                      VoidClosure*       complete_gc,
4738
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   181
                                      YieldClosure*      yield,
25586a89c1c3 6895236: CMS: cmsOopClosures.inline.hpp:43 assert(..., "Should remember klasses in this context")
jmasa
parents: 1610
diff changeset
   182
                                      bool               should_unload_classes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // Delete entries in the discovered lists that have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // either a null referent or are not active. Such
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // Reference objects can result from the clearing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // or enqueueing of Reference objects concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  // with their discovery by a (concurrent) collector.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // For a definition of "active" see java.lang.ref.Reference;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // Refs are born active, become inactive when enqueued,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // and never become active again. The state of being
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  // active is encoded as follows: A Ref is active
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  // if and only if its "next" field is NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  void clean_up_discovered_references();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  void clean_up_discovered_reflist(DiscoveredList& refs_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Returns the name of the discovered reference list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // occupying the i / _num_q slot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  const char* list_name(int i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   201
  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
   202
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // "Preclean" the given discovered reference list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  // by removing references with strongly reachable referents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  // Currently used in support of CMS only.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  void preclean_discovered_reflist(DiscoveredList&    refs_list,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
                                   BoolObjectClosure* is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
                                   OopClosure*        keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
                                   VoidClosure*       complete_gc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
                                   YieldClosure*      yield);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  int next_id() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    int id = _next_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    if (++_next_id == _num_q) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
      _next_id = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    return id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  DiscoveredList* get_discovered_list(ReferenceType rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  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
   222
                                        HeapWord* discovered_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  void verify_ok_to_handle_reflists() PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  void abandon_partial_discovered_list(DiscoveredList& refs_list);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  // Calculate the number of jni handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  unsigned int count_jni_refs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  // Balances reference queues.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  void balance_queues(DiscoveredList ref_lists[]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  // Update (advance) the soft ref master clock field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  void update_soft_ref_master_clock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  ReferenceProcessor():
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    _span((HeapWord*)NULL, (HeapWord*)NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    _discoveredSoftRefs(NULL),  _discoveredWeakRefs(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    _discoveredFinalRefs(NULL), _discoveredPhantomRefs(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    _discovering_refs(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    _discovery_is_atomic(true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    _enqueuing_is_done(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    _discovery_is_mt(false),
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   246
    _discovered_list_needs_barrier(false),
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   247
    _bs(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    _is_alive_non_header(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    _num_q(0),
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   250
    _max_num_q(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
    _processing_is_mt(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    _next_id(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  ReferenceProcessor(MemRegion span, bool atomic_discovery,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   256
                     bool mt_discovery,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   257
                     int mt_degree = 1,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   258
                     bool mt_processing = false,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   259
                     bool discovered_list_needs_barrier = false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  // Allocates and initializes a reference processor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  static ReferenceProcessor* create_ref_processor(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    MemRegion          span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
    bool               atomic_discovery,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    bool               mt_discovery,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    BoolObjectClosure* is_alive_non_header = NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    int                parallel_gc_threads = 1,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   268
    bool               mt_processing = false,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   269
    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
   270
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // RefDiscoveryPolicy values
4885
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   272
  enum DiscoveryPolicy {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    ReferenceBasedDiscovery = 0,
4885
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   274
    ReferentBasedDiscovery  = 1,
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   275
    DiscoveryPolicyMin      = ReferenceBasedDiscovery,
cee90a57b58f 6885297: java -XX:RefDiscoveryPolicy=2 or -XX:TLABWasteTargetPercent=0 cause VM crash
johnc
parents: 4738
diff changeset
   276
    DiscoveryPolicyMax      = ReferentBasedDiscovery
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  static void init_statics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // get and set "is_alive_non_header" field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  BoolObjectClosure* is_alive_non_header() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    return _is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  void set_is_alive_non_header(BoolObjectClosure* is_alive_non_header) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    _is_alive_non_header = is_alive_non_header;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // get and set span
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  MemRegion span()                   { return _span; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  void      set_span(MemRegion span) { _span = span; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // start and stop weak ref discovery
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  void enable_discovery()   { _discovering_refs = true;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  void disable_discovery()  { _discovering_refs = false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  bool discovery_enabled()  { return _discovering_refs;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // whether discovery is atomic wrt other collectors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  bool discovery_is_atomic() const { return _discovery_is_atomic; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  void set_atomic_discovery(bool atomic) { _discovery_is_atomic = atomic; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // whether discovery is done by multiple threads same-old-timeously
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  bool discovery_is_mt() const { return _discovery_is_mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  void set_mt_discovery(bool mt) { _discovery_is_mt = mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // Whether we are in a phase when _processing_ is MT.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  bool processing_is_mt() const { return _processing_is_mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  void set_mt_processing(bool mt) { _processing_is_mt = mt; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // whether all enqueuing of weak references is complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  bool enqueuing_is_done()  { return _enqueuing_is_done; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  void set_enqueuing_is_done(bool v) { _enqueuing_is_done = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // iterate over oops
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  void weak_oops_do(OopClosure* f);       // weak roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  static void oops_do(OopClosure* f);     // strong root(s)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   319
  // Balance each of the discovered lists.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   320
  void balance_all_queues();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   321
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  // Discover a Reference object, using appropriate discovery criteria
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  bool discover_reference(oop obj, ReferenceType rt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  // 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
   326
  void process_discovered_references(BoolObjectClosure*           is_alive,
1
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
                                     AbstractRefProcTaskExecutor* task_executor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  // Enqueue references at end of GC (called by the garbage collector)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  bool enqueue_discovered_references(AbstractRefProcTaskExecutor* task_executor = NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   335
  // 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
   336
  // 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
   337
  // 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
   338
  void abandon_partial_discovery();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   339
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  void verify_no_references_recorded() PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  static void verify();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // clear the discovered lists (unlinking each entry).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  void clear_discovered_references() PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
// A utility class to disable reference discovery in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
// the scope which contains it, for given ReferenceProcessor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
class NoRefDiscovery: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  bool _was_discovering_refs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  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
   356
    _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
   357
    if (_was_discovering_refs) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
      _rp->disable_discovery();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  ~NoRefDiscovery() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    if (_was_discovering_refs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
      _rp->enable_discovery();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
// A utility class to temporarily mutate the span of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
class ReferenceProcessorSpanMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  MemRegion           _saved_span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  ReferenceProcessorSpanMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
                                MemRegion span):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    _saved_span = _rp->span();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    _rp->set_span(span);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  ~ReferenceProcessorSpanMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    _rp->set_span(_saved_span);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
// A utility class to temporarily change the MT'ness of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
// reference discovery for the given ReferenceProcessor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
// in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
class ReferenceProcessorMTMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  bool                _saved_mt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  ReferenceProcessorMTMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
                              bool mt):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
    _saved_mt = _rp->discovery_is_mt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
    _rp->set_mt_discovery(mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  ~ReferenceProcessorMTMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
    _rp->set_mt_discovery(_saved_mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
// A utility class to temporarily change the disposition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
// of the "is_alive_non_header" closure field of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
class ReferenceProcessorIsAliveMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  BoolObjectClosure*  _saved_cl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  ReferenceProcessorIsAliveMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
                                   BoolObjectClosure*  cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    _saved_cl = _rp->is_alive_non_header();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    _rp->set_is_alive_non_header(cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  ~ReferenceProcessorIsAliveMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    _rp->set_is_alive_non_header(_saved_cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
// A utility class to temporarily change the disposition
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
// of the "discovery_is_atomic" field of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
// given ReferenceProcessor in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
class ReferenceProcessorAtomicMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  bool                _saved_atomic_discovery;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  ReferenceProcessorAtomicMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
                                  bool atomic):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
    _saved_atomic_discovery = _rp->discovery_is_atomic();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
    _rp->set_atomic_discovery(atomic);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  ~ReferenceProcessorAtomicMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
    _rp->set_atomic_discovery(_saved_atomic_discovery);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
// A utility class to temporarily change the MT processing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
// disposition of the given ReferenceProcessor instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
// in the scope that contains it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
class ReferenceProcessorMTProcMutator: StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  ReferenceProcessor* _rp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  bool  _saved_mt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  ReferenceProcessorMTProcMutator(ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
                                  bool mt):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    _rp(rp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    _saved_mt = _rp->processing_is_mt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    _rp->set_mt_processing(mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  ~ReferenceProcessorMTProcMutator() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
    _rp->set_mt_processing(_saved_mt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
// This class is an interface used to implement task execution for the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
// reference processing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
class AbstractRefProcTaskExecutor {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  // Abstract tasks to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  class ProcessTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  class EnqueueTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  // Executes a task using worker threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  virtual void execute(ProcessTask& task) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  virtual void execute(EnqueueTask& task) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // Switch to single threaded mode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  virtual void set_single_threaded_mode() { };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
// Abstract reference processing task to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
class AbstractRefProcTaskExecutor::ProcessTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  ProcessTask(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
              DiscoveredList      refs_lists[],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
              bool                marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
    : _ref_processor(ref_processor),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
      _refs_lists(refs_lists),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
      _marks_oops_alive(marks_oops_alive)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  virtual void work(unsigned int work_id, BoolObjectClosure& is_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
                    OopClosure& keep_alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
                    VoidClosure& complete_gc) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // Returns true if a task marks some oops as alive.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  bool marks_oops_alive() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  { return _marks_oops_alive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  ReferenceProcessor& _ref_processor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  DiscoveredList*     _refs_lists;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  const bool          _marks_oops_alive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
// Abstract reference processing task to execute.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
class AbstractRefProcTaskExecutor::EnqueueTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  EnqueueTask(ReferenceProcessor& ref_processor,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
              DiscoveredList      refs_lists[],
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   525
              HeapWord*           pending_list_addr,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
              oop                 sentinel_ref,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
              int                 n_queues)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
    : _ref_processor(ref_processor),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
      _refs_lists(refs_lists),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
      _pending_list_addr(pending_list_addr),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
      _sentinel_ref(sentinel_ref),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
      _n_queues(n_queues)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  virtual void work(unsigned int work_id) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  ReferenceProcessor& _ref_processor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  DiscoveredList*     _refs_lists;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   541
  HeapWord*           _pending_list_addr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  oop                 _sentinel_ref;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  int                 _n_queues;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
};