src/hotspot/share/gc/parallel/psCompactionManager.cpp
author erikj
Tue, 12 Sep 2017 19:03:39 +0200
changeset 47216 71c04702a3d5
parent 46502 hotspot/src/share/vm/gc/parallel/psCompactionManager.cpp@116a09d8f142
child 49041 44122f767467
permissions -rw-r--r--
8187443: Forest Consolidation: Move files to unified layout Reviewed-by: darcy, ihse
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
35877
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
     2
 * Copyright (c) 2005, 2016, 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: 5080
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5080
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: 5080
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: 6762
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    26
#include "classfile/systemDictionary.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    27
#include "gc/parallel/gcTaskManager.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    28
#include "gc/parallel/objectStartArray.hpp"
46502
116a09d8f142 8180755: Remove use of bitMap.inline.hpp include from instanceKlass.hpp and c1_ValueSet.hpp
tschatzl
parents: 40655
diff changeset
    29
#include "gc/parallel/parMarkBitMap.inline.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    30
#include "gc/parallel/parallelScavengeHeap.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    31
#include "gc/parallel/psCompactionManager.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    32
#include "gc/parallel/psOldGen.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    33
#include "gc/parallel/psParallelCompact.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30566
diff changeset
    34
#include "gc/shared/taskqueue.inline.hpp"
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33611
diff changeset
    35
#include "logging/log.hpp"
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
    36
#include "memory/iterator.inline.hpp"
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
    37
#include "oops/instanceKlass.inline.hpp"
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
    38
#include "oops/instanceMirrorKlass.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    39
#include "oops/objArrayKlass.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    40
#include "oops/oop.inline.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 38170
diff changeset
    41
#include "runtime/atomic.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
PSOldGen*            ParCompactionManager::_old_gen = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
ParCompactionManager**  ParCompactionManager::_manager_array = NULL;
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 7397
diff changeset
    45
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
OopTaskQueueSet*     ParCompactionManager::_stack_array = NULL;
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    47
ParCompactionManager::ObjArrayTaskQueueSet*
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    48
  ParCompactionManager::_objarray_queues = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
ObjectStartArray*    ParCompactionManager::_start_array = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
ParMarkBitMap*       ParCompactionManager::_mark_bitmap = NULL;
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
    51
RegionTaskQueueSet*  ParCompactionManager::_region_array = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
ParCompactionManager::ParCompactionManager() :
38170
ff88a25a7799 8150994: UseParallelGC fails with UseDynamicNumberOfGCThreads with specjbb2005
jmasa
parents: 35877
diff changeset
    54
    _action(CopyAndUpdate) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30151
diff changeset
    56
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  _old_gen = heap->old_gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  _start_array = old_gen()->start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  marking_stack()->initialize();
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
    62
  _objarray_stack.initialize();
38170
ff88a25a7799 8150994: UseParallelGC fails with UseDynamicNumberOfGCThreads with specjbb2005
jmasa
parents: 35877
diff changeset
    63
  _region_stack.initialize();
35877
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
    64
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
    65
  reset_bitmap_query_cache();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 7397
diff changeset
    66
}
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 7397
diff changeset
    67
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  assert(PSParallelCompact::gc_task_manager() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
    "Needed for initialization");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  _mark_bitmap = mbm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  assert(_manager_array == NULL, "Attempt to initialize twice");
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11178
diff changeset
    77
  _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC);
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    78
  guarantee(_manager_array != NULL, "Could not allocate manager_array");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  _stack_array = new OopTaskQueueSet(parallel_gc_threads);
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    81
  guarantee(_stack_array != NULL, "Could not allocate stack_array");
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    82
  _objarray_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    83
  guarantee(_objarray_queues != NULL, "Could not allocate objarray_queues");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
    84
  _region_array = new RegionTaskQueueSet(parallel_gc_threads);
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
    85
  guarantee(_region_array != NULL, "Could not allocate region_array");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  // Create and register the ParCompactionManager(s) for the worker threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  for(uint i=0; i<parallel_gc_threads; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    _manager_array[i] = new ParCompactionManager();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    stack_array()->register_queue(i, _manager_array[i]->marking_stack());
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
    92
    _objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
38170
ff88a25a7799 8150994: UseParallelGC fails with UseDynamicNumberOfGCThreads with specjbb2005
jmasa
parents: 35877
diff changeset
    93
    region_array()->register_queue(i, _manager_array[i]->region_stack());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // The VMThread gets its own ParCompactionManager, which is not available
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // for work stealing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  _manager_array[parallel_gc_threads] = new ParCompactionManager();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  guarantee(_manager_array[parallel_gc_threads] != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    "Could not create ParCompactionManager");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  assert(PSParallelCompact::gc_task_manager()->workers() != 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    "Not initialized?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
35877
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   105
void ParCompactionManager::reset_all_bitmap_query_caches() {
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   106
  uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   107
  for (uint i=0; i<=parallel_gc_threads; i++) {
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   108
    _manager_array[i]->reset_bitmap_query_cache();
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   109
  }
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   110
}
a2a62511d0f8 8146987: Improve Parallel GC Full GC by caching results of live_words_in_range()
tschatzl
parents: 35061
diff changeset
   111
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
bool ParCompactionManager::should_update() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  assert(action() != NotValid, "Action is not set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  return (action() == ParCompactionManager::Update) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
         (action() == ParCompactionManager::CopyAndUpdate) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
         (action() == ParCompactionManager::UpdateAndCopy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
bool ParCompactionManager::should_copy() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  assert(action() != NotValid, "Action is not set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  return (action() == ParCompactionManager::Copy) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
         (action() == ParCompactionManager::CopyAndUpdate) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
         (action() == ParCompactionManager::UpdateAndCopy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
ParCompactionManager*
31330
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 30764
diff changeset
   127
ParCompactionManager::gc_thread_compaction_manager(uint index) {
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 30764
diff changeset
   128
  assert(index < ParallelGCThreads, "index out of range");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  assert(_manager_array != NULL, "Sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  return _manager_array[index];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   133
void InstanceKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   134
  assert(obj != NULL, "can't follow the content of NULL object");
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   135
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   136
  cm->follow_klass(this);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   137
  // Only mark the header and let the scan of the meta-data mark
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   138
  // everything else.
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   139
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   140
  ParCompactionManager::MarkAndPushClosure cl(cm);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   141
  InstanceKlass::oop_oop_iterate_oop_maps<true>(obj, &cl);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   142
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   143
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   144
void InstanceMirrorKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   145
  InstanceKlass::oop_pc_follow_contents(obj, cm);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   146
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   147
  // Follow the klass field in the mirror.
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   148
  Klass* klass = java_lang_Class::as_Klass(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   149
  if (klass != NULL) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   150
    // An anonymous class doesn't have its own class loader, so the call
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   151
    // to follow_klass will mark and push its java mirror instead of the
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   152
    // class loader. When handling the java mirror for an anonymous class
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   153
    // we need to make sure its class loader data is claimed, this is done
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   154
    // by calling follow_class_loader explicitly. For non-anonymous classes
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   155
    // the call to follow_class_loader is made when the class loader itself
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   156
    // is handled.
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 31330
diff changeset
   157
    if (klass->is_instance_klass() && InstanceKlass::cast(klass)->is_anonymous()) {
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   158
      cm->follow_class_loader(klass->class_loader_data());
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   159
    } else {
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   160
      cm->follow_klass(klass);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   161
    }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   162
  } else {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   163
    // If klass is NULL then this a mirror for a primitive type.
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   164
    // We don't have to follow them, since they are handled as strong
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   165
    // roots in Universe::oops_do.
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   166
    assert(java_lang_Class::is_primitive(obj), "Sanity check");
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   167
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   168
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   169
  ParCompactionManager::MarkAndPushClosure cl(cm);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   170
  oop_oop_iterate_statics<true>(obj, &cl);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   171
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   172
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   173
void InstanceClassLoaderKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   174
  InstanceKlass::oop_pc_follow_contents(obj, cm);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   175
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   176
  ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   177
  if (loader_data != NULL) {
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   178
    cm->follow_class_loader(loader_data);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   179
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   180
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   181
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   182
template <class T>
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   183
static void oop_pc_follow_contents_specialized(InstanceRefKlass* klass, oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   184
  T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   185
  T heap_oop = oopDesc::load_heap_oop(referent_addr);
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33611
diff changeset
   186
  log_develop_trace(gc, ref)("InstanceRefKlass::oop_pc_follow_contents " PTR_FORMAT, p2i(obj));
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   187
  if (!oopDesc::is_null(heap_oop)) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   188
    oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   189
    if (PSParallelCompact::mark_bitmap()->is_unmarked(referent) &&
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   190
        PSParallelCompact::ref_processor()->discover_reference(obj, klass->reference_type())) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   191
      // reference already enqueued, referent will be traversed later
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   192
      klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33611
diff changeset
   193
      log_develop_trace(gc, ref)("       Non NULL enqueued " PTR_FORMAT, p2i(obj));
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   194
      return;
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   195
    } else {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   196
      // treat referent as normal oop
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33611
diff changeset
   197
      log_develop_trace(gc, ref)("       Non NULL normal " PTR_FORMAT, p2i(obj));
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   198
      cm->mark_and_push(referent_addr);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   199
    }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   200
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   201
  T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
30558
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   202
  // Treat discovered as normal oop, if ref is not "active",
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   203
  // i.e. if next is non-NULL.
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   204
  T  next_oop = oopDesc::load_heap_oop(next_addr);
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   205
  if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active"
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   206
    T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33611
diff changeset
   207
    log_develop_trace(gc, ref)("   Process discovered as normal " PTR_FORMAT, p2i(discovered_addr));
30558
baec90a2699f 8031401: Remove unused code in the reference processor
kbarrett
parents: 30556
diff changeset
   208
    cm->mark_and_push(discovered_addr);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   209
  }
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   210
  cm->mark_and_push(next_addr);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   211
  klass->InstanceKlass::oop_pc_follow_contents(obj, cm);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   212
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   213
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   214
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   215
void InstanceRefKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   216
  if (UseCompressedOops) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   217
    oop_pc_follow_contents_specialized<narrowOop>(this, obj, cm);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   218
  } else {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   219
    oop_pc_follow_contents_specialized<oop>(this, obj, cm);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   220
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   221
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   222
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   223
void ObjArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30173
diff changeset
   224
  cm->follow_klass(this);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   225
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   226
  if (UseCompressedOops) {
30151
c7cdaa576875 8076456: Remove unnecessary oopDesc::klass() calls
stefank
parents: 30150
diff changeset
   227
    oop_pc_follow_contents_specialized<narrowOop>(objArrayOop(obj), 0, cm);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   228
  } else {
30151
c7cdaa576875 8076456: Remove unnecessary oopDesc::klass() calls
stefank
parents: 30150
diff changeset
   229
    oop_pc_follow_contents_specialized<oop>(objArrayOop(obj), 0, cm);
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   230
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   231
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   232
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   233
void TypeArrayKlass::oop_pc_follow_contents(oop obj, ParCompactionManager* cm) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   234
  assert(obj->is_typeArray(),"must be a type array");
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   235
  // Performance tweak: We skip iterating over the klass pointer since we
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   236
  // know that Universe::TypeArrayKlass never moves.
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   237
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29792
diff changeset
   238
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   239
void ParCompactionManager::follow_marking_stacks() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  do {
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   241
    // Drain the overflow stack first, to allow stealing from the marking stack.
5080
eff0cc882603 6935839: excessive marking stack growth during full gcs
jcoomes
parents: 5076
diff changeset
   242
    oop obj;
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
   243
    while (marking_stack()->pop_overflow(obj)) {
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 25351
diff changeset
   244
      follow_contents(obj);
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   245
    }
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   246
    while (marking_stack()->pop_local(obj)) {
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 25351
diff changeset
   247
      follow_contents(obj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
5080
eff0cc882603 6935839: excessive marking stack growth during full gcs
jcoomes
parents: 5076
diff changeset
   250
    // Process ObjArrays one at a time to avoid marking stack bloat.
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   251
    ObjArrayTask task;
17370
59a0620561fa 8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents: 13952
diff changeset
   252
    if (_objarray_stack.pop_overflow(task) || _objarray_stack.pop_local(task)) {
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 25351
diff changeset
   253
      follow_contents((objArrayOop)task.obj(), task.index());
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   254
    }
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   255
  } while (!marking_stacks_empty());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
5076
8b74a4b60b31 4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents: 3795
diff changeset
   257
  assert(marking_stacks_empty(), "Sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   260
void ParCompactionManager::drain_region_stacks() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  do {
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
   262
    // Drain overflow stack first so other threads can steal.
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
   263
    size_t region_index;
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
   264
    while (region_stack()->pop_overflow(region_index)) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   265
      PSParallelCompact::fill_and_update_region(this, region_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5547
diff changeset
   268
    while (region_stack()->pop_local(region_index)) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   269
      PSParallelCompact::fill_and_update_region(this, region_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
    }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   271
  } while (!region_stack()->is_empty());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
}