hotspot/src/share/vm/memory/genOopClosures.inline.hpp
author tonyp
Tue, 08 Nov 2011 00:41:28 -0500
changeset 10997 0be4b3be7197
parent 7397 5b173b4ca846
child 13728 882756847a04
permissions -rw-r--r--
7099849: G1: include heap region information in hs_err files Reviewed-by: johnc, brutisso, poonam
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
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: 3262
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3262
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: 3262
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: 5547
diff changeset
    25
#ifndef SHARE_VM_MEMORY_GENOOPCLOSURES_INLINE_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#define SHARE_VM_MEMORY_GENOOPCLOSURES_INLINE_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "memory/cardTableRS.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "memory/defNewGeneration.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "memory/genCollectedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "memory/genOopClosures.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "memory/genRemSet.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "memory/generation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "memory/sharedHeap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "memory/space.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    36
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
inline OopsInGenClosure::OopsInGenClosure(Generation* gen) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  OopClosure(gen->ref_processor()), _orig_gen(gen), _rs(NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  set_generation(gen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
inline void OopsInGenClosure::set_generation(Generation* gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  _gen = gen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  _gen_boundary = _gen->reserved().start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  // Barrier set for the heap, must be set after heap is initialized
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  if (_rs == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
    GenRemSet* rs = SharedHeap::heap()->rem_set();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
    assert(rs->rs_kind() == GenRemSet::CardTable, "Wrong rem set kind");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
    _rs = (CardTableRS*)rs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    53
template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  assert(generation()->is_in_reserved(p), "expected ref in generation");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    55
  T heap_oop = oopDesc::load_heap_oop(p);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    56
  assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    57
  oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  // If p points to a younger generation, mark the card.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  if ((HeapWord*)obj < _gen_boundary) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    _rs->inline_write_ref_field_gc(p, obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    64
template <class T> inline void OopsInGenClosure::par_do_barrier(T* p) {
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    65
  assert(generation()->is_in_reserved(p), "expected ref in generation");
3262
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    66
  T heap_oop = oopDesc::load_heap_oop(p);
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    67
  assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
30d1c247fc25 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 1388
diff changeset
    68
  oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    69
  // If p points to a younger generation, mark the card.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    70
  if ((HeapWord*)obj < gen_boundary()) {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    71
    rs()->write_ref_field_gc_par(p, obj);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    72
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    73
}
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
    74
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// NOTE! Any changes made here should also be made
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    76
// in FastScanClosure::do_oop_work()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    77
template <class T> inline void ScanClosure::do_oop_work(T* p) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    78
  T heap_oop = oopDesc::load_heap_oop(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // Should we copy the obj?
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    80
  if (!oopDesc::is_null(heap_oop)) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    81
    oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    if ((HeapWord*)obj < _boundary) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
      assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    84
      oop new_obj = obj->is_forwarded() ? obj->forwardee()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    85
                                        : _g->copy_to_survivor_space(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    86
      oopDesc::encode_store_heap_oop_not_null(p, new_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
    if (_gc_barrier) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
      // Now call parent closure
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
      do_barrier(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    95
inline void ScanClosure::do_oop_nv(oop* p)       { ScanClosure::do_oop_work(p); }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    96
inline void ScanClosure::do_oop_nv(narrowOop* p) { ScanClosure::do_oop_work(p); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
// NOTE! Any changes made here should also be made
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
    99
// in ScanClosure::do_oop_work()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   100
template <class T> inline void FastScanClosure::do_oop_work(T* p) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   101
  T heap_oop = oopDesc::load_heap_oop(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Should we copy the obj?
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   103
  if (!oopDesc::is_null(heap_oop)) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   104
    oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    if ((HeapWord*)obj < _boundary) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
      assert(!_g->to()->is_in_reserved(obj), "Scanning field twice?");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   107
      oop new_obj = obj->is_forwarded() ? obj->forwardee()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   108
                                        : _g->copy_to_survivor_space(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   109
      oopDesc::encode_store_heap_oop_not_null(p, new_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
      if (_gc_barrier) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
        // Now call parent closure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
        do_barrier(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   118
inline void FastScanClosure::do_oop_nv(oop* p)       { FastScanClosure::do_oop_work(p); }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   119
inline void FastScanClosure::do_oop_nv(narrowOop* p) { FastScanClosure::do_oop_work(p); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
// Note similarity to ScanClosure; the difference is that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
// the barrier set is taken care of outside this closure.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   123
template <class T> inline void ScanWeakRefClosure::do_oop_work(T* p) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   124
  assert(!oopDesc::is_null(*p), "null weak reference?");
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   125
  oop obj = oopDesc::load_decode_heap_oop_not_null(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // weak references are sometimes scanned twice; must check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // that to-space doesn't already contain this object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  if ((HeapWord*)obj < _boundary && !_g->to()->is_in_reserved(obj)) {
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   129
    oop new_obj = obj->is_forwarded() ? obj->forwardee()
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   130
                                      : _g->copy_to_survivor_space(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   131
    oopDesc::encode_store_heap_oop_not_null(p, new_obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   135
inline void ScanWeakRefClosure::do_oop_nv(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   136
inline void ScanWeakRefClosure::do_oop_nv(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   137
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   138
#endif // SHARE_VM_MEMORY_GENOOPCLOSURES_INLINE_HPP