hotspot/src/share/vm/gc/parallel/psParallelCompact.cpp
author david
Fri, 16 Oct 2015 14:11:29 +0200
changeset 33227 b00ec45f8c2c
parent 33107 77bf0d2069a3
child 33230 23bb11a5cf4e
permissions -rw-r--r--
8139277: Remove ScavengeWithObjectsInToSpace, ParallelOldGCSplitALot, ParallelOldGCSplitInterval, PSAdjustTenuredGenForMinorPause and PSAdjustYoungGenForMajorPause Reviewed-by: tschatzl, sjohanss
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
29325
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
     2
 * Copyright (c) 2005, 2015, 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: 5402
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5402
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: 5402
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"
24426
0a69c8cdfca9 8038654: Separate SymbolTable and StringTable code
gziemski
parents: 24092
diff changeset
    26
#include "classfile/stringTable.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    27
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    28
#include "code/codeCache.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    29
#include "gc/parallel/gcTaskManager.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    30
#include "gc/parallel/parallelScavengeHeap.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    31
#include "gc/parallel/pcTasks.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    32
#include "gc/parallel/psAdaptiveSizePolicy.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    33
#include "gc/parallel/psCompactionManager.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    34
#include "gc/parallel/psMarkSweep.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    35
#include "gc/parallel/psMarkSweepDecorator.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    36
#include "gc/parallel/psOldGen.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    37
#include "gc/parallel/psParallelCompact.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    38
#include "gc/parallel/psPromotionManager.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    39
#include "gc/parallel/psScavenge.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    40
#include "gc/parallel/psYoungGen.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    41
#include "gc/shared/gcCause.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    42
#include "gc/shared/gcHeapSummary.hpp"
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
    43
#include "gc/shared/gcId.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    44
#include "gc/shared/gcLocker.inline.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    45
#include "gc/shared/gcTimer.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    46
#include "gc/shared/gcTrace.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    47
#include "gc/shared/gcTraceTime.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    48
#include "gc/shared/isGCActiveMark.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    49
#include "gc/shared/referencePolicy.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    50
#include "gc/shared/referenceProcessor.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    51
#include "gc/shared/spaceDecorator.hpp"
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
    52
#include "oops/instanceKlass.inline.hpp"
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
    53
#include "oops/instanceMirrorKlass.inline.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    54
#include "oops/methodData.hpp"
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
    55
#include "oops/objArrayKlass.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    56
#include "oops/oop.inline.hpp"
25351
7c198a690050 8044775: Improve usage of umbrella header atomic.inline.hpp.
goetz
parents: 25350
diff changeset
    57
#include "runtime/atomic.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    58
#include "runtime/fprofiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    59
#include "runtime/safepoint.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    60
#include "runtime/vmThread.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    61
#include "services/management.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30556
diff changeset
    62
#include "services/memTracker.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    63
#include "services/memoryService.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    64
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6762
diff changeset
    65
#include "utilities/stack.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
#include <math.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// All sizes are in HeapWords.
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    70
const size_t ParallelCompactData::Log2RegionSize  = 16; // 64K words
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    71
const size_t ParallelCompactData::RegionSize      = (size_t)1 << Log2RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    72
const size_t ParallelCompactData::RegionSizeBytes =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    73
  RegionSize << LogHeapWordSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    74
const size_t ParallelCompactData::RegionSizeOffsetMask = RegionSize - 1;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    75
const size_t ParallelCompactData::RegionAddrOffsetMask = RegionSizeBytes - 1;
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    76
const size_t ParallelCompactData::RegionAddrMask       = ~RegionAddrOffsetMask;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    77
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    78
const size_t ParallelCompactData::Log2BlockSize   = 7; // 128 words
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    79
const size_t ParallelCompactData::BlockSize       = (size_t)1 << Log2BlockSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    80
const size_t ParallelCompactData::BlockSizeBytes  =
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    81
  BlockSize << LogHeapWordSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    82
const size_t ParallelCompactData::BlockSizeOffsetMask = BlockSize - 1;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    83
const size_t ParallelCompactData::BlockAddrOffsetMask = BlockSizeBytes - 1;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    84
const size_t ParallelCompactData::BlockAddrMask       = ~BlockAddrOffsetMask;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    85
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    86
const size_t ParallelCompactData::BlocksPerRegion = RegionSize / BlockSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    87
const size_t ParallelCompactData::Log2BlocksPerRegion =
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
    88
  Log2RegionSize - Log2BlockSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    90
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    91
ParallelCompactData::RegionData::dc_shift = 27;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    92
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    93
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    94
ParallelCompactData::RegionData::dc_mask = ~0U << dc_shift;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    95
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    96
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    97
ParallelCompactData::RegionData::dc_one = 0x1U << dc_shift;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    98
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
    99
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   100
ParallelCompactData::RegionData::los_mask = ~dc_mask;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   101
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   102
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   103
ParallelCompactData::RegionData::dc_claimed = 0x8U << dc_shift;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   104
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   105
const ParallelCompactData::RegionData::region_sz_t
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   106
ParallelCompactData::RegionData::dc_completed = 0xcU << dc_shift;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
bool      PSParallelCompact::_print_phases = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
ReferenceProcessor* PSParallelCompact::_ref_processor = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
double PSParallelCompact::_dwl_mean;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
double PSParallelCompact::_dwl_std_dev;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
double PSParallelCompact::_dwl_first_term;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
double PSParallelCompact::_dwl_adjustment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
bool   PSParallelCompact::_dwl_initialized = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   121
void SplitInfo::record(size_t src_region_idx, size_t partial_obj_size,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   122
                       HeapWord* destination)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   123
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   124
  assert(src_region_idx != 0, "invalid src_region_idx");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   125
  assert(partial_obj_size != 0, "invalid partial_obj_size argument");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   126
  assert(destination != NULL, "invalid destination argument");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   127
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   128
  _src_region_idx = src_region_idx;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   129
  _partial_obj_size = partial_obj_size;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   130
  _destination = destination;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   131
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   132
  // These fields may not be updated below, so make sure they're clear.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   133
  assert(_dest_region_addr == NULL, "should have been cleared");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   134
  assert(_first_src_addr == NULL, "should have been cleared");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   135
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   136
  // Determine the number of destination regions for the partial object.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   137
  HeapWord* const last_word = destination + partial_obj_size - 1;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   138
  const ParallelCompactData& sd = PSParallelCompact::summary_data();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   139
  HeapWord* const beg_region_addr = sd.region_align_down(destination);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   140
  HeapWord* const end_region_addr = sd.region_align_down(last_word);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   141
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   142
  if (beg_region_addr == end_region_addr) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   143
    // One destination region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   144
    _destination_count = 1;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   145
    if (end_region_addr == destination) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   146
      // The destination falls on a region boundary, thus the first word of the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   147
      // partial object will be the first word copied to the destination region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   148
      _dest_region_addr = end_region_addr;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   149
      _first_src_addr = sd.region_to_addr(src_region_idx);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   150
    }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   151
  } else {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   152
    // Two destination regions.  When copied, the partial object will cross a
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   153
    // destination region boundary, so a word somewhere within the partial
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   154
    // object will be the first word copied to the second destination region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   155
    _destination_count = 2;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   156
    _dest_region_addr = end_region_addr;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   157
    const size_t ofs = pointer_delta(end_region_addr, destination);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   158
    assert(ofs < _partial_obj_size, "sanity");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   159
    _first_src_addr = sd.region_to_addr(src_region_idx) + ofs;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   160
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   161
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   162
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   163
void SplitInfo::clear()
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   164
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   165
  _src_region_idx = 0;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   166
  _partial_obj_size = 0;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   167
  _destination = NULL;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   168
  _destination_count = 0;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   169
  _dest_region_addr = NULL;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   170
  _first_src_addr = NULL;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   171
  assert(!is_valid(), "sanity");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   172
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   173
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   174
#ifdef  ASSERT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   175
void SplitInfo::verify_clear()
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   176
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   177
  assert(_src_region_idx == 0, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   178
  assert(_partial_obj_size == 0, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   179
  assert(_destination == NULL, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   180
  assert(_destination_count == 0, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   181
  assert(_dest_region_addr == NULL, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   182
  assert(_first_src_addr == NULL, "not clear");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   183
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   184
#endif  // #ifdef ASSERT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   185
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   186
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 15088
diff changeset
   187
void PSParallelCompact::print_on_error(outputStream* st) {
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 15088
diff changeset
   188
  _mark_bitmap.print_on_error(st);
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 15088
diff changeset
   189
}
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 15088
diff changeset
   190
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
const char* PSParallelCompact::space_names[] = {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   193
  "old ", "eden", "from", "to  "
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   196
void PSParallelCompact::print_region_ranges()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  tty->print_cr("space  bottom     top        end        new_top");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  tty->print_cr("------ ---------- ---------- ---------- ----------");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  for (unsigned int id = 0; id < last_space_id; ++id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    const MutableSpace* space = _space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    tty->print_cr("%u %s "
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   204
                  SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " "
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   205
                  SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10) " ",
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
                  id, space_names[id],
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   207
                  summary_data().addr_to_region_idx(space->bottom()),
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   208
                  summary_data().addr_to_region_idx(space->top()),
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   209
                  summary_data().addr_to_region_idx(space->end()),
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   210
                  summary_data().addr_to_region_idx(_space_info[id].new_top()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
void
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   215
print_generic_summary_region(size_t i, const ParallelCompactData::RegionData* c)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   217
#define REGION_IDX_FORMAT        SIZE_FORMAT_W(7)
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   218
#define REGION_DATA_FORMAT       SIZE_FORMAT_W(5)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  ParallelCompactData& sd = PSParallelCompact::summary_data();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   221
  size_t dci = c->destination() ? sd.addr_to_region_idx(c->destination()) : 0;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   222
  tty->print_cr(REGION_IDX_FORMAT " " PTR_FORMAT " "
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   223
                REGION_IDX_FORMAT " " PTR_FORMAT " "
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   224
                REGION_DATA_FORMAT " " REGION_DATA_FORMAT " "
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   225
                REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d",
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   226
                i, p2i(c->data_location()), dci, p2i(c->destination()),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
                c->partial_obj_size(), c->live_obj_size(),
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   228
                c->data_size(), c->source_region(), c->destination_count());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   229
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   230
#undef  REGION_IDX_FORMAT
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   231
#undef  REGION_DATA_FORMAT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
print_generic_summary_data(ParallelCompactData& summary_data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
                           HeapWord* const beg_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
                           HeapWord* const end_addr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  size_t total_words = 0;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   240
  size_t i = summary_data.addr_to_region_idx(beg_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   241
  const size_t last = summary_data.addr_to_region_idx(end_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  HeapWord* pdest = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  while (i <= last) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   245
    ParallelCompactData::RegionData* c = summary_data.region(i);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    if (c->data_size() != 0 || c->destination() != pdest) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   247
      print_generic_summary_region(i, c);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
      total_words += c->data_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
      pdest = c->destination();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  tty->print_cr("summary_data_bytes=" SIZE_FORMAT, total_words * HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
print_generic_summary_data(ParallelCompactData& summary_data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
                           SpaceInfo* space_info)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  for (unsigned int id = 0; id < PSParallelCompact::last_space_id; ++id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    const MutableSpace* space = space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
    print_generic_summary_data(summary_data, space->bottom(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
                               MAX2(space->top(), space_info[id].new_top()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
void
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   269
print_initial_summary_region(size_t i,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   270
                             const ParallelCompactData::RegionData* c,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   271
                             bool newline = true)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
{
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   273
  tty->print(SIZE_FORMAT_W(5) " " PTR_FORMAT " "
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   274
             SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " "
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   275
             SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d",
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   276
             i, p2i(c->destination()),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
             c->partial_obj_size(), c->live_obj_size(),
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   278
             c->data_size(), c->source_region(), c->destination_count());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  if (newline) tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
print_initial_summary_data(ParallelCompactData& summary_data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
                           const MutableSpace* space) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  if (space->top() == space->bottom()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   289
  const size_t region_size = ParallelCompactData::RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   290
  typedef ParallelCompactData::RegionData RegionData;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   291
  HeapWord* const top_aligned_up = summary_data.region_align_up(space->top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   292
  const size_t end_region = summary_data.addr_to_region_idx(top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   293
  const RegionData* c = summary_data.region(end_region - 1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  HeapWord* end_addr = c->destination() + c->data_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  const size_t live_in_space = pointer_delta(end_addr, space->bottom());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   297
  // Print (and count) the full regions at the beginning of the space.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   298
  size_t full_region_count = 0;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   299
  size_t i = summary_data.addr_to_region_idx(space->bottom());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   300
  while (i < end_region && summary_data.region(i)->data_size() == region_size) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   301
    print_initial_summary_region(i, summary_data.region(i));
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   302
    ++full_region_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   306
  size_t live_to_right = live_in_space - full_region_count * region_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  double max_reclaimed_ratio = 0.0;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   309
  size_t max_reclaimed_ratio_region = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  size_t max_dead_to_right = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  size_t max_live_to_right = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   313
  // Print the 'reclaimed ratio' for regions while there is something live in
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   314
  // the region or to the right of it.  The remaining regions are empty (and
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // uninteresting), and computing the ratio will result in division by 0.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   316
  while (i < end_region && live_to_right > 0) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   317
    c = summary_data.region(i);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   318
    HeapWord* const region_addr = summary_data.region_to_addr(i);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   319
    const size_t used_to_right = pointer_delta(space->top(), region_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    const size_t dead_to_right = used_to_right - live_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    const double reclaimed_ratio = double(dead_to_right) / live_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    if (reclaimed_ratio > max_reclaimed_ratio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
            max_reclaimed_ratio = reclaimed_ratio;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   325
            max_reclaimed_ratio_region = i;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
            max_dead_to_right = dead_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
            max_live_to_right = live_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   330
    print_initial_summary_region(i, c, false);
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   331
    tty->print_cr(" %12.10f " SIZE_FORMAT_W(10) " " SIZE_FORMAT_W(10),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
                  reclaimed_ratio, dead_to_right, live_to_right);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    live_to_right -= c->data_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    ++i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   338
  // Any remaining regions are empty.  Print one more if there is one.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   339
  if (i < end_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   340
    print_initial_summary_region(i, summary_data.region(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   343
  tty->print_cr("max:  " SIZE_FORMAT_W(4) " d2r=" SIZE_FORMAT_W(10) " "
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
   344
                "l2r=" SIZE_FORMAT_W(10) " max_ratio=%14.12f",
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   345
                max_reclaimed_ratio_region, max_dead_to_right,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
                max_live_to_right, max_reclaimed_ratio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
print_initial_summary_data(ParallelCompactData& summary_data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
                           SpaceInfo* space_info) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   352
  unsigned int id = PSParallelCompact::old_space_id;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  const MutableSpace* space;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    space = space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    print_initial_summary_data(summary_data, space);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  } while (++id < PSParallelCompact::eden_space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    space = space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    print_generic_summary_data(summary_data, space->bottom(), space->top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  } while (++id < PSParallelCompact::last_space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
size_t add_obj_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
size_t add_obj_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
size_t mark_bitmap_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
size_t mark_bitmap_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
ParallelCompactData::ParallelCompactData()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  _region_start = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   377
  _region_vspace = 0;
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   378
  _reserved_byte_size = 0;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   379
  _region_data = 0;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   380
  _region_count = 0;
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   381
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   382
  _block_vspace = 0;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   383
  _block_data = 0;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   384
  _block_count = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
bool ParallelCompactData::initialize(MemRegion covered_region)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  _region_start = covered_region.start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  const size_t region_size = covered_region.word_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  DEBUG_ONLY(_region_end = _region_start + region_size;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   393
  assert(region_align_down(_region_start) == _region_start,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
         "region start not aligned");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   395
  assert((region_size & RegionSizeOffsetMask) == 0,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   396
         "region size not a multiple of RegionSize");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   397
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   398
  bool result = initialize_region_data(region_size) && initialize_block_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
PSVirtualSpace*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
ParallelCompactData::create_vspace(size_t count, size_t element_size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  const size_t raw_bytes = count * element_size;
28631
a56cae1b428d 8066875: VirtualSpace does not use large pages
ehelin
parents: 28212
diff changeset
   406
  const size_t page_sz = os::page_size_for_region_aligned(raw_bytes, 10);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  const size_t granularity = os::vm_allocation_granularity();
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   408
  _reserved_byte_size = align_size_up(raw_bytes, MAX2(page_sz, granularity));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  const size_t rs_align = page_sz == (size_t) os::vm_page_size() ? 0 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
    MAX2(page_sz, granularity);
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   412
  ReservedSpace rs(_reserved_byte_size, rs_align, rs_align > 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  os::trace_page_sizes("par compact", raw_bytes, raw_bytes, page_sz, rs.base(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
                       rs.size());
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   415
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   416
  MemTracker::record_virtual_memory_type((address)rs.base(), mtGC);
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   417
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  PSVirtualSpace* vspace = new PSVirtualSpace(rs, page_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  if (vspace != 0) {
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   420
    if (vspace->expand_by(_reserved_byte_size)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      return vspace;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    delete vspace;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 781
diff changeset
   424
    // Release memory reserved in the space.
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 781
diff changeset
   425
    rs.release();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   431
bool ParallelCompactData::initialize_region_data(size_t region_size)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   433
  const size_t count = (region_size + RegionSizeOffsetMask) >> Log2RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   434
  _region_vspace = create_vspace(count, sizeof(RegionData));
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   435
  if (_region_vspace != 0) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   436
    _region_data = (RegionData*)_region_vspace->reserved_low_addr();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   437
    _region_count = count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   443
bool ParallelCompactData::initialize_block_data()
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   444
{
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   445
  assert(_region_count != 0, "region data must be initialized first");
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   446
  const size_t count = _region_count << Log2BlocksPerRegion;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   447
  _block_vspace = create_vspace(count, sizeof(BlockData));
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   448
  if (_block_vspace != 0) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   449
    _block_data = (BlockData*)_block_vspace->reserved_low_addr();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   450
    _block_count = count;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   451
    return true;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   452
  }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   453
  return false;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   454
}
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   455
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
void ParallelCompactData::clear()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   458
  memset(_region_data, 0, _region_vspace->committed_size());
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   459
  memset(_block_data, 0, _block_vspace->committed_size());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   462
void ParallelCompactData::clear_range(size_t beg_region, size_t end_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   463
  assert(beg_region <= _region_count, "beg_region out of range");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   464
  assert(end_region <= _region_count, "end_region out of range");
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   465
  assert(RegionSize % BlockSize == 0, "RegionSize not a multiple of BlockSize");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   466
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   467
  const size_t region_cnt = end_region - beg_region;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   468
  memset(_region_data + beg_region, 0, region_cnt * sizeof(RegionData));
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   469
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   470
  const size_t beg_block = beg_region * BlocksPerRegion;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   471
  const size_t block_cnt = region_cnt * BlocksPerRegion;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   472
  memset(_block_data + beg_block, 0, block_cnt * sizeof(BlockData));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   475
HeapWord* ParallelCompactData::partial_obj_end(size_t region_idx) const
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   477
  const RegionData* cur_cp = region(region_idx);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   478
  const RegionData* const end_cp = region(region_count() - 1);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   479
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   480
  HeapWord* result = region_to_addr(region_idx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  if (cur_cp < end_cp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
      result += cur_cp->partial_obj_size();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   484
    } while (cur_cp->partial_obj_size() == RegionSize && ++cur_cp < end_cp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
void ParallelCompactData::add_obj(HeapWord* addr, size_t len)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  const size_t obj_ofs = pointer_delta(addr, _region_start);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   492
  const size_t beg_region = obj_ofs >> Log2RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   493
  const size_t end_region = (obj_ofs + len - 1) >> Log2RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  DEBUG_ONLY(Atomic::inc_ptr(&add_obj_count);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  DEBUG_ONLY(Atomic::add_ptr(len, &add_obj_size);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   498
  if (beg_region == end_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   499
    // All in one region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   500
    _region_data[beg_region].add_live_obj(len);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   504
  // First region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   505
  const size_t beg_ofs = region_offset(addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   506
  _region_data[beg_region].add_live_obj(RegionSize - beg_ofs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   508
  Klass* klass = ((oop)addr)->klass();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   509
  // Middle regions--completely spanned by this object.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   510
  for (size_t region = beg_region + 1; region < end_region; ++region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   511
    _region_data[region].set_partial_obj_size(RegionSize);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   512
    _region_data[region].set_partial_obj_addr(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   515
  // Last region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   516
  const size_t end_ofs = region_offset(addr + len - 1);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   517
  _region_data[end_region].set_partial_obj_size(end_ofs + 1);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   518
  _region_data[end_region].set_partial_obj_addr(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
ParallelCompactData::summarize_dense_prefix(HeapWord* beg, HeapWord* end)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   524
  assert(region_offset(beg) == 0, "not RegionSize aligned");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   525
  assert(region_offset(end) == 0, "not RegionSize aligned");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   526
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   527
  size_t cur_region = addr_to_region_idx(beg);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   528
  const size_t end_region = addr_to_region_idx(end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  HeapWord* addr = beg;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   530
  while (cur_region < end_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   531
    _region_data[cur_region].set_destination(addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   532
    _region_data[cur_region].set_destination_count(0);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   533
    _region_data[cur_region].set_source_region(cur_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   534
    _region_data[cur_region].set_data_location(addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   535
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   536
    // Update live_obj_size so the region appears completely full.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   537
    size_t live_size = RegionSize - _region_data[cur_region].partial_obj_size();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   538
    _region_data[cur_region].set_live_obj_size(live_size);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   539
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   540
    ++cur_region;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   541
    addr += RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   545
// Find the point at which a space can be split and, if necessary, record the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   546
// split point.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   547
//
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   548
// If the current src region (which overflowed the destination space) doesn't
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   549
// have a partial object, the split point is at the beginning of the current src
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   550
// region (an "easy" split, no extra bookkeeping required).
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   551
//
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   552
// If the current src region has a partial object, the split point is in the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   553
// region where that partial object starts (call it the split_region).  If
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   554
// split_region has a partial object, then the split point is just after that
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   555
// partial object (a "hard" split where we have to record the split data and
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   556
// zero the partial_obj_size field).  With a "hard" split, we know that the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   557
// partial_obj ends within split_region because the partial object that caused
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   558
// the overflow starts in split_region.  If split_region doesn't have a partial
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   559
// obj, then the split is at the beginning of split_region (another "easy"
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   560
// split).
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   561
HeapWord*
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   562
ParallelCompactData::summarize_split_space(size_t src_region,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   563
                                           SplitInfo& split_info,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   564
                                           HeapWord* destination,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   565
                                           HeapWord* target_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   566
                                           HeapWord** target_next)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   567
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   568
  assert(destination <= target_end, "sanity");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   569
  assert(destination + _region_data[src_region].data_size() > target_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   570
    "region should not fit into target space");
2363
f09f17e0ebc7 6810474: par compact - crash in summary_phase with very full heap
jcoomes
parents: 2154
diff changeset
   571
  assert(is_region_aligned(target_end), "sanity");
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   572
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   573
  size_t split_region = src_region;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   574
  HeapWord* split_destination = destination;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   575
  size_t partial_obj_size = _region_data[src_region].partial_obj_size();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   576
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   577
  if (destination + partial_obj_size > target_end) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   578
    // The split point is just after the partial object (if any) in the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   579
    // src_region that contains the start of the object that overflowed the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   580
    // destination space.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   581
    //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   582
    // Find the start of the "overflow" object and set split_region to the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   583
    // region containing it.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   584
    HeapWord* const overflow_obj = _region_data[src_region].partial_obj_addr();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   585
    split_region = addr_to_region_idx(overflow_obj);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   586
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   587
    // Clear the source_region field of all destination regions whose first word
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   588
    // came from data after the split point (a non-null source_region field
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   589
    // implies a region must be filled).
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   590
    //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   591
    // An alternative to the simple loop below:  clear during post_compact(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   592
    // which uses memcpy instead of individual stores, and is easy to
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   593
    // parallelize.  (The downside is that it clears the entire RegionData
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   594
    // object as opposed to just one field.)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   595
    //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   596
    // post_compact() would have to clear the summary data up to the highest
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   597
    // address that was written during the summary phase, which would be
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   598
    //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   599
    //         max(top, max(new_top, clear_top))
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   600
    //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   601
    // where clear_top is a new field in SpaceInfo.  Would have to set clear_top
2363
f09f17e0ebc7 6810474: par compact - crash in summary_phase with very full heap
jcoomes
parents: 2154
diff changeset
   602
    // to target_end.
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   603
    const RegionData* const sr = region(split_region);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   604
    const size_t beg_idx =
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   605
      addr_to_region_idx(region_align_up(sr->destination() +
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   606
                                         sr->partial_obj_size()));
2363
f09f17e0ebc7 6810474: par compact - crash in summary_phase with very full heap
jcoomes
parents: 2154
diff changeset
   607
    const size_t end_idx = addr_to_region_idx(target_end);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   608
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   609
    if (TraceParallelOldGCSummaryPhase) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   610
        gclog_or_tty->print_cr("split:  clearing source_region field in ["
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   611
                               SIZE_FORMAT ", " SIZE_FORMAT ")",
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   612
                               beg_idx, end_idx);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   613
    }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   614
    for (size_t idx = beg_idx; idx < end_idx; ++idx) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   615
      _region_data[idx].set_source_region(0);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   616
    }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   617
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   618
    // Set split_destination and partial_obj_size to reflect the split region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   619
    split_destination = sr->destination();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   620
    partial_obj_size = sr->partial_obj_size();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   621
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   622
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   623
  // The split is recorded only if a partial object extends onto the region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   624
  if (partial_obj_size != 0) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   625
    _region_data[split_region].set_partial_obj_size(0);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   626
    split_info.record(split_region, partial_obj_size, split_destination);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   627
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   628
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   629
  // Setup the continuation addresses.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   630
  *target_next = split_destination + partial_obj_size;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   631
  HeapWord* const source_next = region_to_addr(split_region) + partial_obj_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  if (TraceParallelOldGCSummaryPhase) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   634
    const char * split_type = partial_obj_size == 0 ? "easy" : "hard";
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   635
    gclog_or_tty->print_cr("%s split:  src=" PTR_FORMAT " src_c=" SIZE_FORMAT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   636
                           " pos=" SIZE_FORMAT,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   637
                           split_type, p2i(source_next), split_region,
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   638
                           partial_obj_size);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   639
    gclog_or_tty->print_cr("%s split:  dst=" PTR_FORMAT " dst_c=" SIZE_FORMAT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   640
                           " tn=" PTR_FORMAT,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   641
                           split_type, p2i(split_destination),
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   642
                           addr_to_region_idx(split_destination),
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   643
                           p2i(*target_next));
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   644
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   645
    if (partial_obj_size != 0) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   646
      HeapWord* const po_beg = split_info.destination();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   647
      HeapWord* const po_end = po_beg + split_info.partial_obj_size();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   648
      gclog_or_tty->print_cr("%s split:  "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   649
                             "po_beg=" PTR_FORMAT " " SIZE_FORMAT " "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   650
                             "po_end=" PTR_FORMAT " " SIZE_FORMAT,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   651
                             split_type,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   652
                             p2i(po_beg), addr_to_region_idx(po_beg),
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   653
                             p2i(po_end), addr_to_region_idx(po_end));
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   654
    }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   655
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   656
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   657
  return source_next;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   658
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   659
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   660
bool ParallelCompactData::summarize(SplitInfo& split_info,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   661
                                    HeapWord* source_beg, HeapWord* source_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   662
                                    HeapWord** source_next,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   663
                                    HeapWord* target_beg, HeapWord* target_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   664
                                    HeapWord** target_next)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   665
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   666
  if (TraceParallelOldGCSummaryPhase) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   667
    HeapWord* const source_next_val = source_next == NULL ? NULL : *source_next;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   668
    tty->print_cr("sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   669
                  "tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   670
                  p2i(source_beg), p2i(source_end), p2i(source_next_val),
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
   671
                  p2i(target_beg), p2i(target_end), p2i(*target_next));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   674
  size_t cur_region = addr_to_region_idx(source_beg);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   675
  const size_t end_region = addr_to_region_idx(region_align_up(source_end));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  HeapWord *dest_addr = target_beg;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   678
  while (cur_region < end_region) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   679
    // The destination must be set even if the region has no data.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   680
    _region_data[cur_region].set_destination(dest_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   681
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   682
    size_t words = _region_data[cur_region].data_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    if (words > 0) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   684
      // If cur_region does not fit entirely into the target space, find a point
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   685
      // at which the source space can be 'split' so that part is copied to the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   686
      // target space and the rest is copied elsewhere.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   687
      if (dest_addr + words > target_end) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   688
        assert(source_next != NULL, "source_next is NULL when splitting");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   689
        *source_next = summarize_split_space(cur_region, split_info, dest_addr,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   690
                                             target_end, target_next);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   691
        return false;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   692
      }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   693
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   694
      // Compute the destination_count for cur_region, and if necessary, update
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   695
      // source_region for a destination region.  The source_region field is
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   696
      // updated if cur_region is the first (left-most) region to be copied to a
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   697
      // destination region.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   698
      //
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   699
      // The destination_count calculation is a bit subtle.  A region that has
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   700
      // data that compacts into itself does not count itself as a destination.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   701
      // This maintains the invariant that a zero count means the region is
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   702
      // available and can be claimed and then filled.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   703
      uint destination_count = 0;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   704
      if (split_info.is_split(cur_region)) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   705
        // The current region has been split:  the partial object will be copied
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   706
        // to one destination space and the remaining data will be copied to
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   707
        // another destination space.  Adjust the initial destination_count and,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   708
        // if necessary, set the source_region field if the partial object will
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   709
        // cross a destination region boundary.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   710
        destination_count = split_info.destination_count();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   711
        if (destination_count == 2) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   712
          size_t dest_idx = addr_to_region_idx(split_info.dest_region_addr());
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   713
          _region_data[dest_idx].set_source_region(cur_region);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   714
        }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   715
      }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   716
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      HeapWord* const last_addr = dest_addr + words - 1;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   718
      const size_t dest_region_1 = addr_to_region_idx(dest_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   719
      const size_t dest_region_2 = addr_to_region_idx(last_addr);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   720
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   721
      // Initially assume that the destination regions will be the same and
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      // adjust the value below if necessary.  Under this assumption, if
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   723
      // cur_region == dest_region_2, then cur_region will be compacted
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   724
      // completely into itself.
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   725
      destination_count += cur_region == dest_region_2 ? 0 : 1;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   726
      if (dest_region_1 != dest_region_2) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   727
        // Destination regions differ; adjust destination_count.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
        destination_count += 1;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   729
        // Data from cur_region will be copied to the start of dest_region_2.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   730
        _region_data[dest_region_2].set_source_region(cur_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   731
      } else if (region_offset(dest_addr) == 0) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   732
        // Data from cur_region will be copied to the start of the destination
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   733
        // region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   734
        _region_data[dest_region_1].set_source_region(cur_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   737
      _region_data[cur_region].set_destination_count(destination_count);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   738
      _region_data[cur_region].set_data_location(region_to_addr(cur_region));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
      dest_addr += words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   742
    ++cur_region;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  *target_next = dest_addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
HeapWord* ParallelCompactData::calc_new_pointer(HeapWord* addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  assert(addr != NULL, "Should detect NULL oop earlier");
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
   751
  assert(ParallelScavengeHeap::heap()->is_in(addr), "not in heap");
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   752
  assert(PSParallelCompact::mark_bitmap()->is_marked(addr), "not marked");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   754
  // Region covering the object.
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   755
  RegionData* const region_ptr = addr_to_region_ptr(addr);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   756
  HeapWord* result = region_ptr->destination();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   757
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   758
  // If the entire Region is live, the new location is region->destination + the
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   759
  // offset of the object within in the Region.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   760
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   761
  // Run some performance tests to determine if this special case pays off.  It
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   762
  // is worth it for pointers into the dense prefix.  If the optimization to
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   763
  // avoid pointer updates in regions that only point to the dense prefix is
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   764
  // ever implemented, this should be revisited.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   765
  if (region_ptr->data_size() == RegionSize) {
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   766
    result += region_offset(addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   770
  // Otherwise, the new location is region->destination + block offset + the
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   771
  // number of live words in the Block that are (a) to the left of addr and (b)
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   772
  // due to objects that start in the Block.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   773
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   774
  // Fill in the block table if necessary.  This is unsynchronized, so multiple
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   775
  // threads may fill the block table for a region (harmless, since it is
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   776
  // idempotent).
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   777
  if (!region_ptr->blocks_filled()) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   778
    PSParallelCompact::fill_blocks(addr_to_region_idx(addr));
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   779
    region_ptr->set_blocks_filled();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   780
  }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   781
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   782
  HeapWord* const search_start = block_align_down(addr);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   783
  const size_t block_offset = addr_to_block_ptr(addr)->offset();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  const ParMarkBitMap* bitmap = PSParallelCompact::mark_bitmap();
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   786
  const size_t live = bitmap->live_words_in_range(search_start, oop(addr));
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   787
  result += block_offset + live;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   788
  DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   792
#ifdef ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
void ParallelCompactData::verify_clear(const PSVirtualSpace* vspace)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  const size_t* const beg = (const size_t*)vspace->committed_low_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  const size_t* const end = (const size_t*)vspace->committed_high_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  for (const size_t* p = beg; p < end; ++p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    assert(*p == 0, "not zero");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
void ParallelCompactData::verify_clear()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   804
  verify_clear(_region_vspace);
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
   805
  verify_clear(_block_vspace);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
   809
STWGCTimer          PSParallelCompact::_gc_timer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
   810
ParallelOldTracer   PSParallelCompact::_gc_tracer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
elapsedTimer        PSParallelCompact::_accumulated_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
unsigned int        PSParallelCompact::_total_invocations = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
unsigned int        PSParallelCompact::_maximum_compaction_gc_num = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
jlong               PSParallelCompact::_time_of_last_gc = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
CollectorCounters*  PSParallelCompact::_counters = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
ParMarkBitMap       PSParallelCompact::_mark_bitmap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
ParallelCompactData PSParallelCompact::_summary_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
PSParallelCompact::IsAliveClosure PSParallelCompact::_is_alive_closure;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 252
diff changeset
   820
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 252
diff changeset
   821
bool PSParallelCompact::IsAliveClosure::do_object_b(oop p) { return mark_bitmap()->is_marked(p); }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 252
diff changeset
   822
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
   823
PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   824
PSParallelCompact::AdjustKlassClosure PSParallelCompact::_adjust_klass_closure;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   826
void PSParallelCompact::AdjustKlassClosure::do_klass(Klass* klass) {
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
   827
  klass->oops_do(&PSParallelCompact::_adjust_pointer_closure);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   828
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   829
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
void PSParallelCompact::post_initialize() {
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
   831
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  MemRegion mr = heap->reserved_region();
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 8076
diff changeset
   833
  _ref_processor =
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 8076
diff changeset
   834
    new ReferenceProcessor(mr,            // span
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 8076
diff changeset
   835
                           ParallelRefProcEnabled && (ParallelGCThreads > 1), // mt processing
31330
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 31032
diff changeset
   836
                           ParallelGCThreads, // mt processing degree
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 31032
diff changeset
   837
                           true,              // mt discovery
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 31032
diff changeset
   838
                           ParallelGCThreads, // mt discovery degree
77061bb01b18 8081382: Make flags ParallelGCThreads and ConcGCThreads of type uint
david
parents: 31032
diff changeset
   839
                           true,              // atomic_discovery
24845
e8b8894a77df 8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects
brutisso
parents: 24429
diff changeset
   840
                           &_is_alive_closure); // non-header is alive closure
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  _counters = new CollectorCounters("PSParallelCompact", 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  // Initialize static fields in ParCompactionManager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  ParCompactionManager::initialize(mark_bitmap());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
bool PSParallelCompact::initialize() {
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
   848
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  MemRegion mr = heap->reserved_region();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  // Was the old gen get allocated successfully?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  if (!heap->old_gen()->is_allocated()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  initialize_space_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  initialize_dead_wood_limiter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  if (!_mark_bitmap.initialize(mr)) {
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   860
    vm_shutdown_during_initialization(
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   861
      err_msg("Unable to allocate " SIZE_FORMAT "KB bitmaps for parallel "
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   862
      "garbage collection for the requested " SIZE_FORMAT "KB heap.",
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   863
      _mark_bitmap.reserved_byte_size()/K, mr.byte_size()/K));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  if (!_summary_data.initialize(mr)) {
17627
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   868
    vm_shutdown_during_initialization(
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   869
      err_msg("Unable to allocate " SIZE_FORMAT "KB card tables for parallel "
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   870
      "garbage collection for the requested " SIZE_FORMAT "KB heap.",
325871034f2c 7186737: Unable to allocate bit maps or card tables for parallel gc for the requested heap
tamao
parents: 17625
diff changeset
   871
      _summary_data.reserved_byte_size()/K, mr.byte_size()/K));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
void PSParallelCompact::initialize_space_info()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  memset(&_space_info, 0, sizeof(_space_info));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
   882
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  PSYoungGen* young_gen = heap->young_gen();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   884
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  _space_info[old_space_id].set_space(heap->old_gen()->object_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  _space_info[eden_space_id].set_space(young_gen->eden_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  _space_info[from_space_id].set_space(young_gen->from_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  _space_info[to_space_id].set_space(young_gen->to_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  _space_info[old_space_id].set_start_array(heap->old_gen()->start_array());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
void PSParallelCompact::initialize_dead_wood_limiter()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  const size_t max = 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  _dwl_mean = double(MIN2(ParallelOldDeadWoodLimiterMean, max)) / 100.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  _dwl_std_dev = double(MIN2(ParallelOldDeadWoodLimiterStdDev, max)) / 100.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  _dwl_first_term = 1.0 / (sqrt(2.0 * M_PI) * _dwl_std_dev);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  DEBUG_ONLY(_dwl_initialized = true;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  _dwl_adjustment = normal_distribution(1.0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
// Simple class for storing info about the heap at the start of GC, to be used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
// after GC for comparison/printing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
class PreGCValues {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  PreGCValues() { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  PreGCValues(ParallelScavengeHeap* heap) { fill(heap); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  void fill(ParallelScavengeHeap* heap) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
    _heap_used      = heap->used();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
    _young_gen_used = heap->young_gen()->used_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
    _old_gen_used   = heap->old_gen()->used_in_bytes();
23854
50f7f89b34e0 8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents: 23226
diff changeset
   914
    _metadata_used  = MetaspaceAux::used_bytes();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  size_t heap_used() const      { return _heap_used; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  size_t young_gen_used() const { return _young_gen_used; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  size_t old_gen_used() const   { return _old_gen_used; }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   920
  size_t metadata_used() const  { return _metadata_used; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  size_t _heap_used;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  size_t _young_gen_used;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  size_t _old_gen_used;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   926
  size_t _metadata_used;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
PSParallelCompact::clear_data_covering_space(SpaceId id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  // At this point, top is the value before GC, new_top() is the value that will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  // be set at the end of GC.  The marking bitmap is cleared to top; nothing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  // should be marked above top.  The summary data is cleared to the larger of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  // top & new_top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  MutableSpace* const space = _space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  HeapWord* const bot = space->bottom();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  HeapWord* const top = space->top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  HeapWord* const max_top = MAX2(top, _space_info[id].new_top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  const idx_t beg_bit = _mark_bitmap.addr_to_bit(bot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  const idx_t end_bit = BitMap::word_align_up(_mark_bitmap.addr_to_bit(top));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  _mark_bitmap.clear_range(beg_bit, end_bit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   945
  const size_t beg_region = _summary_data.addr_to_region_idx(bot);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   946
  const size_t end_region =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   947
    _summary_data.addr_to_region_idx(_summary_data.region_align_up(max_top));
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
   948
  _summary_data.clear_range(beg_region, end_region);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   949
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   950
  // Clear the data used to 'split' regions.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   951
  SplitInfo& split_info = _space_info[id].split_info();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   952
  if (split_info.is_valid()) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   953
    split_info.clear();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   954
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
   955
  DEBUG_ONLY(split_info.verify_clear();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
void PSParallelCompact::pre_compact(PreGCValues* pre_gc_values)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  // Update the from & to space pointers in space_info, since they are swapped
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  // at each young gen gc.  Do the update unconditionally (even though a
32623
390a27af5657 8134626: Misc cleanups after generation array removal
jwilhelm
parents: 31634
diff changeset
   962
  // promotion failure does not swap spaces) because an unknown number of young
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  // collections will have swapped the spaces an unknown number of times.
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
   964
  GCTraceTime tm("pre compact", print_phases(), true, &_gc_timer);
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
   965
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  _space_info[from_space_id].set_space(heap->young_gen()->from_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
  _space_info[to_space_id].set_space(heap->young_gen()->to_space());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  pre_gc_values->fill(heap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  DEBUG_ONLY(add_obj_count = add_obj_size = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  DEBUG_ONLY(mark_bitmap_count = mark_bitmap_size = 0;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  // Increment the invocation count
386
7f121b1192f2 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents: 1
diff changeset
   975
  heap->increment_total_collections(true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  // We need to track unique mark sweep invocations as well.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  _total_invocations++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11251
diff changeset
   980
  heap->print_heap_before_gc();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
   981
  heap->trace_heap_before_gc(&_gc_tracer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  // Fill in TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
  heap->accumulate_statistics_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  heap->ensure_parsability(true);  // retire TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  if (VerifyBeforeGC && heap->total_collections() >= VerifyGCStartAt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    HandleMark hm;  // Discard invalid handles created during verification
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 17109
diff changeset
   989
    Universe::verify(" VerifyBeforeGC:");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  // Verify object start arrays
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  if (VerifyObjectStartArray &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
      VerifyBeforeGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
    heap->old_gen()->verify_object_start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  DEBUG_ONLY(mark_bitmap()->verify_clear();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  DEBUG_ONLY(summary_data().verify_clear();)
756
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1000
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1001
  // Have worker threads release resources the next time they run a task.
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1002
  gc_task_manager()->release_all_resources();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
void PSParallelCompact::post_compact()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
{
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  1007
  GCTraceTime tm("post compact", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1009
  for (unsigned int id = old_space_id; id < last_space_id; ++id) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1010
    // Clear the marking bitmap, summary data and split info.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    clear_data_covering_space(SpaceId(id));
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1012
    // Update top().  Must be done after clearing the bitmap and summary data.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1013
    _space_info[id].publish_new_top();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  MutableSpace* const eden_space = _space_info[eden_space_id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  MutableSpace* const from_space = _space_info[from_space_id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  MutableSpace* const to_space   = _space_info[to_space_id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  1020
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  bool eden_empty = eden_space->is_empty();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  if (!eden_empty) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
    eden_empty = absorb_live_data_from_eden(heap->size_policy(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
                                            heap->young_gen(), heap->old_gen());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  // Update heap occupancy information which is used as input to the soft ref
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  // clearing policy at the next gc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  Universe::update_heap_info_at_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  bool young_gen_empty = eden_empty && from_space->is_empty() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
    to_space->is_empty();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
29325
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1034
  ModRefBarrierSet* modBS = barrier_set_cast<ModRefBarrierSet>(heap->barrier_set());
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1035
  MemRegion old_mr = heap->old_gen()->reserved();
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1036
  if (young_gen_empty) {
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1037
    modBS->clear(MemRegion(old_mr.start(), old_mr.end()));
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1038
  } else {
0e86e64c66e5 8069016: Add BarrierSet downcast support
kbarrett
parents: 28631
diff changeset
  1039
    modBS->invalidate(MemRegion(old_mr.start(), old_mr.end()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1042
  // Delete metaspaces for unloaded class loaders and clean up loader_data graph
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1043
  ClassLoaderDataGraph::purge();
17109
90e6c31bbbe4 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents: 17105
diff changeset
  1044
  MetaspaceAux::verify_metrics();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1045
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  CodeCache::gc_epilogue();
7918
ce1e4ae77aea 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents: 7397
diff changeset
  1047
  JvmtiExport::gc_epilogue();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
  COMPILER2_PRESENT(DerivedPointerTable::update_pointers());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
  ref_processor()->enqueue_discovered_references(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1053
  if (ZapUnusedHeapArea) {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1054
    heap->gen_mangle_unused_area();
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1055
  }
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1056
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  // Update time of last GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  reset_millis_since_last_gc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
PSParallelCompact::compute_dense_prefix_via_density(const SpaceId id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
                                                    bool maximum_compaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1065
  const size_t region_size = ParallelCompactData::RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  const ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  const MutableSpace* const space = _space_info[id].space();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1069
  HeapWord* const top_aligned_up = sd.region_align_up(space->top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1070
  const RegionData* const beg_cp = sd.addr_to_region_ptr(space->bottom());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1071
  const RegionData* const end_cp = sd.addr_to_region_ptr(top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1072
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1073
  // Skip full regions at the beginning of the space--they are necessarily part
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
  // of the dense prefix.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  size_t full_count = 0;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1076
  const RegionData* cp;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1077
  for (cp = beg_cp; cp < end_cp && cp->data_size() == region_size; ++cp) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
    ++full_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
  assert(total_invocations() >= _maximum_compaction_gc_num, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  if (maximum_compaction || cp == end_cp || interval_ended) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
    _maximum_compaction_gc_num = total_invocations();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1086
    return sd.region_to_addr(cp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  HeapWord* const new_top = _space_info[id].new_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  const size_t space_live = pointer_delta(new_top, space->bottom());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  const size_t space_used = space->used_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  const size_t space_capacity = space->capacity_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  const double cur_density = double(space_live) / space_capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  const double deadwood_density =
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
    (1.0 - cur_density) * (1.0 - cur_density) * cur_density * cur_density;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  const size_t deadwood_goal = size_t(space_capacity * deadwood_density);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  if (TraceParallelOldGCDensePrefix) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
    tty->print_cr("cur_dens=%5.3f dw_dens=%5.3f dw_goal=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
                  cur_density, deadwood_density, deadwood_goal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
    tty->print_cr("space_live=" SIZE_FORMAT " " "space_used=" SIZE_FORMAT " "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
                  "space_cap=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
                  space_live, space_used,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
                  space_capacity);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  // XXX - Use binary search?
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1109
  HeapWord* dense_prefix = sd.region_to_addr(cp);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1110
  const RegionData* full_cp = cp;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1111
  const RegionData* const top_cp = sd.addr_to_region_ptr(space->top() - 1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  while (cp < end_cp) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1113
    HeapWord* region_destination = cp->destination();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1114
    const size_t cur_deadwood = pointer_delta(dense_prefix, region_destination);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    if (TraceParallelOldGCDensePrefix && Verbose) {
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
  1116
      tty->print_cr("c#=" SIZE_FORMAT_W(4) " dst=" PTR_FORMAT " "
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1117
                    "dp=" PTR_FORMAT " " "cdw=" SIZE_FORMAT_W(8),
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1118
                    sd.region(cp), p2i(region_destination),
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1119
                    p2i(dense_prefix), cur_deadwood);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
    if (cur_deadwood >= deadwood_goal) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1123
      // Found the region that has the correct amount of deadwood to the left.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1124
      // This typically occurs after crossing a fairly sparse set of regions, so
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1125
      // iterate backwards over those sparse regions, looking for the region
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1126
      // that has the lowest density of live objects 'to the right.'
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1127
      size_t space_to_left = sd.region(cp) * region_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
      size_t live_to_left = space_to_left - cur_deadwood;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
      size_t space_to_right = space_capacity - space_to_left;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
      size_t live_to_right = space_live - live_to_left;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
      double density_to_right = double(live_to_right) / space_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
      while (cp > full_cp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
        --cp;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1134
        const size_t prev_region_live_to_right = live_to_right -
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1135
          cp->data_size();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1136
        const size_t prev_region_space_to_right = space_to_right + region_size;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1137
        double prev_region_density_to_right =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1138
          double(prev_region_live_to_right) / prev_region_space_to_right;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1139
        if (density_to_right <= prev_region_density_to_right) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
          return dense_prefix;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
        if (TraceParallelOldGCDensePrefix && Verbose) {
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
  1143
          tty->print_cr("backing up from c=" SIZE_FORMAT_W(4) " d2r=%10.8f "
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1144
                        "pc_d2r=%10.8f", sd.region(cp), density_to_right,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1145
                        prev_region_density_to_right);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
        }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1147
        dense_prefix -= region_size;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1148
        live_to_right = prev_region_live_to_right;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1149
        space_to_right = prev_region_space_to_right;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1150
        density_to_right = prev_region_density_to_right;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
      return dense_prefix;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1155
    dense_prefix += region_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
    ++cp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  return dense_prefix;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
void PSParallelCompact::print_dense_prefix_stats(const char* const algorithm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
                                                 const SpaceId id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
                                                 const bool maximum_compaction,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
                                                 HeapWord* const addr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1168
  const size_t region_idx = summary_data().addr_to_region_idx(addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1169
  RegionData* const cp = summary_data().region(region_idx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  const MutableSpace* const space = _space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
  HeapWord* const new_top = _space_info[id].new_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  const size_t space_live = pointer_delta(new_top, space->bottom());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  const size_t dead_to_left = pointer_delta(addr, cp->destination());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  const size_t space_cap = space->capacity_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
  const double dead_to_left_pct = double(dead_to_left) / space_cap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  const size_t live_to_right = new_top - cp->destination();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  const size_t dead_to_right = space->top() - addr - live_to_right;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
  1180
  tty->print_cr("%s=" PTR_FORMAT " dpc=" SIZE_FORMAT_W(5) " "
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
                "spl=" SIZE_FORMAT " "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
                "d2l=" SIZE_FORMAT " d2l%%=%6.4f "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
                "d2r=" SIZE_FORMAT " l2r=" SIZE_FORMAT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
                " ratio=%10.8f",
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1185
                algorithm, p2i(addr), region_idx,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
                space_live,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
                dead_to_left, dead_to_left_pct,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
                dead_to_right, live_to_right,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
                double(dead_to_right) / live_to_right);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
// Return a fraction indicating how much of the generation can be treated as
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
// "dead wood" (i.e., not reclaimed).  The function uses a normal distribution
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
// based on the density of live objects in the generation to determine a limit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
// which is then adjusted so the return value is min_percent when the density is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
// 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
// The following table shows some return values for a different values of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
// standard deviation (ParallelOldDeadWoodLimiterStdDev); the mean is 0.5 and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
// min_percent is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
//                          fraction allowed as dead wood
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
//         -----------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
// density std_dev=70 std_dev=75 std_dev=80 std_dev=85 std_dev=90 std_dev=95
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
// ------- ---------- ---------- ---------- ---------- ---------- ----------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
// 0.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
// 0.05000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
// 0.10000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
// 0.15000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
// 0.20000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
// 0.25000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
// 0.30000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
// 0.35000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
// 0.40000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
// 0.45000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
// 0.50000 0.13832410 0.11599237 0.09847664 0.08456518 0.07338887 0.06431510
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
// 0.55000 0.13687208 0.11481163 0.09750361 0.08375387 0.07270534 0.06373386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
// 0.60000 0.13253818 0.11128511 0.09459590 0.08132834 0.07066107 0.06199500
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
// 0.65000 0.12538832 0.10545958 0.08978741 0.07731366 0.06727491 0.05911289
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
// 0.70000 0.11553050 0.09741183 0.08313394 0.07175114 0.06257797 0.05511132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
// 0.75000 0.10311208 0.08724696 0.07471205 0.06469760 0.05661313 0.05002313
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
// 0.80000 0.08831616 0.07509618 0.06461766 0.05622444 0.04943437 0.04388975
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
// 0.85000 0.07135702 0.06111390 0.05296419 0.04641639 0.04110601 0.03676066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
// 0.90000 0.05247504 0.04547452 0.03988045 0.03537016 0.03170171 0.02869272
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
// 0.95000 0.03193096 0.02836880 0.02550828 0.02319280 0.02130337 0.01974941
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
// 1.00000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000 0.01000000
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
double PSParallelCompact::dead_wood_limiter(double density, size_t min_percent)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  assert(_dwl_initialized, "uninitialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  // The raw limit is the value of the normal distribution at x = density.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  const double raw_limit = normal_distribution(density);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  // Adjust the raw limit so it becomes the minimum when the density is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  // First subtract the adjustment value (which is simply the precomputed value
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  // normal_distribution(1.0)); this yields a value of 0 when the density is 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  // Then add the minimum value, so the minimum is returned when the density is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  // 1.  Finally, prevent negative values, which occur when the mean is not 0.5.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  const double min = double(min_percent) / 100.0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  const double limit = raw_limit - _dwl_adjustment + min;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
  return MAX2(limit, 0.0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1247
ParallelCompactData::RegionData*
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1248
PSParallelCompact::first_dead_space_region(const RegionData* beg,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1249
                                           const RegionData* end)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1251
  const size_t region_size = ParallelCompactData::RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  ParallelCompactData& sd = summary_data();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1253
  size_t left = sd.region(beg);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1254
  size_t right = end > beg ? sd.region(end) - 1 : left;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  // Binary search.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  while (left < right) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
    // Equivalent to (left + right) / 2, but does not overflow.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
    const size_t middle = left + (right - left) / 2;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1260
    RegionData* const middle_ptr = sd.region(middle);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
    HeapWord* const dest = middle_ptr->destination();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1262
    HeapWord* const addr = sd.region_to_addr(middle);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
    assert(dest != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
    assert(dest <= addr, "must move left");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
    if (middle > left && dest < addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
      right = middle - 1;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1268
    } else if (middle < right && middle_ptr->data_size() == region_size) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
      left = middle + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
      return middle_ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1274
  return sd.region(left);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1277
ParallelCompactData::RegionData*
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1278
PSParallelCompact::dead_wood_limit_region(const RegionData* beg,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1279
                                          const RegionData* end,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1280
                                          size_t dead_words)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  ParallelCompactData& sd = summary_data();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1283
  size_t left = sd.region(beg);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1284
  size_t right = end > beg ? sd.region(end) - 1 : left;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  // Binary search.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
  while (left < right) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
    // Equivalent to (left + right) / 2, but does not overflow.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
    const size_t middle = left + (right - left) / 2;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1290
    RegionData* const middle_ptr = sd.region(middle);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
    HeapWord* const dest = middle_ptr->destination();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1292
    HeapWord* const addr = sd.region_to_addr(middle);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
    assert(dest != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
    assert(dest <= addr, "must move left");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
    const size_t dead_to_left = pointer_delta(addr, dest);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
    if (middle > left && dead_to_left > dead_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
      right = middle - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
    } else if (middle < right && dead_to_left < dead_words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
      left = middle + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
      return middle_ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1305
  return sd.region(left);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
// The result is valid during the summary phase, after the initial summarization
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
// of each space into itself, and before final summarization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
inline double
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1311
PSParallelCompact::reclaimed_ratio(const RegionData* const cp,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
                                   HeapWord* const bottom,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
                                   HeapWord* const top,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
                                   HeapWord* const new_top)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  assert(cp != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
  assert(bottom != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
  assert(top != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
  assert(new_top != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
  assert(top >= new_top, "summary data problem?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  assert(new_top > bottom, "space is empty; should not be here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  assert(new_top >= cp->destination(), "sanity");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1325
  assert(top >= sd.region_to_addr(cp), "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  HeapWord* const destination = cp->destination();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  const size_t dense_prefix_live  = pointer_delta(destination, bottom);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  const size_t compacted_region_live = pointer_delta(new_top, destination);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1330
  const size_t compacted_region_used = pointer_delta(top,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1331
                                                     sd.region_to_addr(cp));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  const size_t reclaimable = compacted_region_used - compacted_region_live;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  const double divisor = dense_prefix_live + 1.25 * compacted_region_live;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  return double(reclaimable) / divisor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
// Return the address of the end of the dense prefix, a.k.a. the start of the
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1339
// compacted region.  The address is always on a region boundary.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
//
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1341
// Completely full regions at the left are skipped, since no compaction can
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1342
// occur in those regions.  Then the maximum amount of dead wood to allow is
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1343
// computed, based on the density (amount live / capacity) of the generation;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1344
// the region with approximately that amount of dead space to the left is
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1345
// identified as the limit region.  Regions between the last completely full
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1346
// region and the limit region are scanned and the one that has the best
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1347
// (maximum) reclaimed_ratio() is selected.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
PSParallelCompact::compute_dense_prefix(const SpaceId id,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
                                        bool maximum_compaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1352
  const size_t region_size = ParallelCompactData::RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  const ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  const MutableSpace* const space = _space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  HeapWord* const top = space->top();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1357
  HeapWord* const top_aligned_up = sd.region_align_up(top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  HeapWord* const new_top = _space_info[id].new_top();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1359
  HeapWord* const new_top_aligned_up = sd.region_align_up(new_top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  HeapWord* const bottom = space->bottom();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1361
  const RegionData* const beg_cp = sd.addr_to_region_ptr(bottom);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1362
  const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1363
  const RegionData* const new_top_cp =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1364
    sd.addr_to_region_ptr(new_top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1365
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1366
  // Skip full regions at the beginning of the space--they are necessarily part
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  // of the dense prefix.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1368
  const RegionData* const full_cp = first_dead_space_region(beg_cp, new_top_cp);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1369
  assert(full_cp->destination() == sd.region_to_addr(full_cp) ||
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
         space->is_empty(), "no dead space allowed to the left");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1371
  assert(full_cp->data_size() < region_size || full_cp == new_top_cp - 1,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1372
         "region must have dead space");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  // The gc number is saved whenever a maximum compaction is done, and used to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
  // determine when the maximum compaction interval has expired.  This avoids
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  // successive max compactions for different reasons.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  assert(total_invocations() >= _maximum_compaction_gc_num, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  const size_t gcs_since_max = total_invocations() - _maximum_compaction_gc_num;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
  const bool interval_ended = gcs_since_max > HeapMaximumCompactionInterval ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    total_invocations() == HeapFirstMaximumCompactionCount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  if (maximum_compaction || full_cp == top_cp || interval_ended) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    _maximum_compaction_gc_num = total_invocations();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1383
    return sd.region_to_addr(full_cp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  const size_t space_live = pointer_delta(new_top, bottom);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
  const size_t space_used = space->used_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  const size_t space_capacity = space->capacity_in_words();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
  const double density = double(space_live) / double(space_capacity);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1391
  const size_t min_percent_free = MarkSweepDeadRatio;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
  const double limiter = dead_wood_limiter(density, min_percent_free);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
  const size_t dead_wood_max = space_used - space_live;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
  const size_t dead_wood_limit = MIN2(size_t(space_capacity * limiter),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
                                      dead_wood_max);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  if (TraceParallelOldGCDensePrefix) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
    tty->print_cr("space_live=" SIZE_FORMAT " " "space_used=" SIZE_FORMAT " "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
                  "space_cap=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
                  space_live, space_used,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
                  space_capacity);
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23854
diff changeset
  1402
    tty->print_cr("dead_wood_limiter(%6.4f, " SIZE_FORMAT ")=%6.4f "
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
                  "dead_wood_max=" SIZE_FORMAT " dead_wood_limit=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
                  density, min_percent_free, limiter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
                  dead_wood_max, dead_wood_limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1408
  // Locate the region with the desired amount of dead space to the left.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1409
  const RegionData* const limit_cp =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1410
    dead_wood_limit_region(full_cp, top_cp, dead_wood_limit);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1411
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1412
  // Scan from the first region with dead space to the limit region and find the
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
  // one with the best (largest) reclaimed ratio.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  double best_ratio = 0.0;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1415
  const RegionData* best_cp = full_cp;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1416
  for (const RegionData* cp = full_cp; cp < limit_cp; ++cp) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
    double tmp_ratio = reclaimed_ratio(cp, bottom, top, new_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
    if (tmp_ratio > best_ratio) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
      best_cp = cp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
      best_ratio = tmp_ratio;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1424
  return sd.region_to_addr(best_cp);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
void PSParallelCompact::summarize_spaces_quick()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
  for (unsigned int i = 0; i < last_space_id; ++i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
    const MutableSpace* space = _space_info[i].space();
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1431
    HeapWord** nta = _space_info[i].new_top_addr();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1432
    bool result = _summary_data.summarize(_space_info[i].split_info(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1433
                                          space->bottom(), space->top(), NULL,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1434
                                          space->bottom(), space->end(), nta);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1435
    assert(result, "space must fit into itself");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    _space_info[i].set_dense_prefix(space->bottom());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
void PSParallelCompact::fill_dense_prefix_end(SpaceId id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
  HeapWord* const dense_prefix_end = dense_prefix(id);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1443
  const RegionData* region = _summary_data.addr_to_region_ptr(dense_prefix_end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
  const idx_t dense_prefix_bit = _mark_bitmap.addr_to_bit(dense_prefix_end);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1445
  if (dead_space_crosses_boundary(region, dense_prefix_bit)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    // Only enough dead space is filled so that any remaining dead space to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
    // left is larger than the minimum filler object.  (The remainder is filled
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
    // during the copy/update phase.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
    // The size of the dead space to the right of the boundary is not a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    // concern, since compaction will be able to use whatever space is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
    // available.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
    // Here '||' is the boundary, 'x' represents a don't care bit and a box
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    // surrounds the space to be filled with an object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    // In the 32-bit VM, each bit represents two 32-bit words:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    //                              +---+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
    // a) beg_bits:  ...  x   x   x | 0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
    //    end_bits:  ...  x   x   x | 0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
    //                              +---+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
    // In the 64-bit VM, each bit represents one 64-bit word:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    //                              +------------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
    // b) beg_bits:  ...  x   x   x | 0   ||   0 | x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
    //    end_bits:  ...  x   x   1 | 0   ||   0 | x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
    //                              +------------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
    //                          +-------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
    // c) beg_bits:  ...  x   x | 0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
    //    end_bits:  ...  x   1 | 0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
    //                          +-------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    //                      +-----------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
    // d) beg_bits:  ...  x | 0   0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
    //    end_bits:  ...  1 | 0   0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
    //                      +-----------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
    //                          +-------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
    // e) beg_bits:  ...  0   0 | 0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
    //    end_bits:  ...  0   0 | 0   0 | ||   0   x  x  ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
    //                          +-------+
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
    // Initially assume case a, c or e will apply.
5694
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 5402
diff changeset
  1482
    size_t obj_len = CollectedHeap::min_fill_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
    HeapWord* obj_beg = dense_prefix_end - obj_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
#ifdef  _LP64
5694
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 5402
diff changeset
  1486
    if (MinObjAlignment > 1) { // object alignment > heap word size
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 5402
diff changeset
  1487
      // Cases a, c or e.
1e0532a6abff 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents: 5402
diff changeset
  1488
    } else if (_mark_bitmap.is_obj_end(dense_prefix_bit - 2)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
      // Case b above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
      obj_beg = dense_prefix_end - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
    } else if (!_mark_bitmap.is_obj_end(dense_prefix_bit - 3) &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
               _mark_bitmap.is_obj_end(dense_prefix_bit - 4)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
      // Case d above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
      obj_beg = dense_prefix_end - 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
      obj_len = 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
#endif  // #ifdef _LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1499
    CollectedHeap::fill_with_object(obj_beg, obj_len);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
    _mark_bitmap.mark_obj(obj_beg, obj_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
    _summary_data.add_obj(obj_beg, obj_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
    assert(start_array(id) != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
    start_array(id)->allocate_block(obj_beg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
void
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1508
PSParallelCompact::clear_source_region(HeapWord* beg_addr, HeapWord* end_addr)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1509
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1510
  RegionData* const beg_ptr = _summary_data.addr_to_region_ptr(beg_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1511
  HeapWord* const end_aligned_up = _summary_data.region_align_up(end_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1512
  RegionData* const end_ptr = _summary_data.addr_to_region_ptr(end_aligned_up);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1513
  for (RegionData* cur = beg_ptr; cur < end_ptr; ++cur) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1514
    cur->set_source_region(0);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1515
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1516
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1517
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1518
void
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
PSParallelCompact::summarize_space(SpaceId id, bool maximum_compaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  assert(id < last_space_id, "id out of range");
33227
b00ec45f8c2c 8139277: Remove ScavengeWithObjectsInToSpace, ParallelOldGCSplitALot, ParallelOldGCSplitInterval, PSAdjustTenuredGenForMinorPause and PSAdjustYoungGenForMajorPause
david
parents: 33107
diff changeset
  1522
  assert(_space_info[id].dense_prefix() == _space_info[id].space()->bottom(),
1670
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1523
         "should have been reset in summarize_spaces_quick()");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  const MutableSpace* space = _space_info[id].space();
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1526
  if (_space_info[id].new_top() != space->bottom()) {
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1527
    HeapWord* dense_prefix_end = compute_dense_prefix(id, maximum_compaction);
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1528
    _space_info[id].set_dense_prefix(dense_prefix_end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
#ifndef PRODUCT
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1531
    if (TraceParallelOldGCDensePrefix) {
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1532
      print_dense_prefix_stats("ratio", id, maximum_compaction,
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1533
                               dense_prefix_end);
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1534
      HeapWord* addr = compute_dense_prefix_via_density(id, maximum_compaction);
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1535
      print_dense_prefix_stats("density", id, maximum_compaction, addr);
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1536
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
1670
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1539
    // Recompute the summary data, taking into account the dense prefix.  If
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1540
    // every last byte will be reclaimed, then the existing summary data which
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1541
    // compacts everything can be left in place.
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1542
    if (!maximum_compaction && dense_prefix_end != space->bottom()) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1543
      // If dead space crosses the dense prefix boundary, it is (at least
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1544
      // partially) filled with a dummy object, marked live and added to the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1545
      // summary data.  This simplifies the copy/update phase and must be done
1670
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1546
      // before the final locations of objects are determined, to prevent
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1547
      // leaving a fragment of dead space that is too small to fill.
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1548
      fill_dense_prefix_end(id);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1549
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1550
      // Compute the destination of each Region, and thus each object.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1551
      _summary_data.summarize_dense_prefix(space->bottom(), dense_prefix_end);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1552
      _summary_data.summarize(_space_info[id].split_info(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1553
                              dense_prefix_end, space->top(), NULL,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1554
                              dense_prefix_end, space->end(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1555
                              _space_info[id].new_top_addr());
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1556
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
  if (TraceParallelOldGCSummaryPhase) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1560
    const size_t region_size = ParallelCompactData::RegionSize;
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1561
    HeapWord* const dense_prefix_end = _space_info[id].dense_prefix();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1562
    const size_t dp_region = _summary_data.addr_to_region_idx(dense_prefix_end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
    const size_t dp_words = pointer_delta(dense_prefix_end, space->bottom());
973
f00c7826d8c6 6483129: par compact assertion failure (new_top > bottom)
jcoomes
parents: 972
diff changeset
  1564
    HeapWord* const new_top = _space_info[id].new_top();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1565
    const HeapWord* nt_aligned_up = _summary_data.region_align_up(new_top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    const size_t cr_words = pointer_delta(nt_aligned_up, dense_prefix_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    tty->print_cr("id=%d cap=" SIZE_FORMAT " dp=" PTR_FORMAT " "
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1568
                  "dp_region=" SIZE_FORMAT " " "dp_count=" SIZE_FORMAT " "
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
                  "cr_count=" SIZE_FORMAT " " "nt=" PTR_FORMAT,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1570
                  id, space->capacity_in_words(), p2i(dense_prefix_end),
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1571
                  dp_region, dp_words / region_size,
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1572
                  cr_words / region_size, p2i(new_top));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1576
#ifndef PRODUCT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1577
void PSParallelCompact::summary_phase_msg(SpaceId dst_space_id,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1578
                                          HeapWord* dst_beg, HeapWord* dst_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1579
                                          SpaceId src_space_id,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1580
                                          HeapWord* src_beg, HeapWord* src_end)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1581
{
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1582
  if (TraceParallelOldGCSummaryPhase) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1583
    tty->print_cr("summarizing %d [%s] into %d [%s]:  "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1584
                  "src=" PTR_FORMAT "-" PTR_FORMAT " "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1585
                  SIZE_FORMAT "-" SIZE_FORMAT " "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1586
                  "dst=" PTR_FORMAT "-" PTR_FORMAT " "
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1587
                  SIZE_FORMAT "-" SIZE_FORMAT,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1588
                  src_space_id, space_names[src_space_id],
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1589
                  dst_space_id, space_names[dst_space_id],
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1590
                  p2i(src_beg), p2i(src_end),
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1591
                  _summary_data.addr_to_region_idx(src_beg),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1592
                  _summary_data.addr_to_region_idx(src_end),
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1593
                  p2i(dst_beg), p2i(dst_end),
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1594
                  _summary_data.addr_to_region_idx(dst_beg),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1595
                  _summary_data.addr_to_region_idx(dst_end));
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1596
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1597
}
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1598
#endif  // #ifndef PRODUCT
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1599
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
void PSParallelCompact::summary_phase(ParCompactionManager* cm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
                                      bool maximum_compaction)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
{
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  1603
  GCTraceTime tm("summary phase", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
  // trace("2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
  if (TraceParallelOldGCMarkingPhase) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
    tty->print_cr("add_obj_count=" SIZE_FORMAT " "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
                  "add_obj_bytes=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
                  add_obj_count, add_obj_size * HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
    tty->print_cr("mark_bitmap_count=" SIZE_FORMAT " "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
                  "mark_bitmap_bytes=" SIZE_FORMAT,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
                  mark_bitmap_count, mark_bitmap_size * HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  // Quick summarization of each space into itself, to see how much is live.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  summarize_spaces_quick();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  if (TraceParallelOldGCSummaryPhase) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
    tty->print_cr("summary_phase:  after summarizing each space to self");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
    Universe::print();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1623
    NOT_PRODUCT(print_region_ranges());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
    if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
      NOT_PRODUCT(print_initial_summary_data(_summary_data, _space_info));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
  // The amount of live data that will end up in old space (assuming it fits).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
  size_t old_space_total_live = 0;
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1631
  for (unsigned int id = old_space_id; id < last_space_id; ++id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
    old_space_total_live += pointer_delta(_space_info[id].new_top(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
                                          _space_info[id].space()->bottom());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1636
  MutableSpace* const old_space = _space_info[old_space_id].space();
1670
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1637
  const size_t old_capacity = old_space->capacity_in_words();
0deb85ea62d5 6765954: par compact - stress mode for splitting young gen spaces
jcoomes
parents: 1669
diff changeset
  1638
  if (old_space_total_live > old_capacity) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
    // XXX - should also try to expand
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    maximum_compaction = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1643
  // Old generations.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  summarize_space(old_space_id, maximum_compaction);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1646
  // Summarize the remaining spaces in the young gen.  The initial target space
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1647
  // is the old gen.  If a space does not fit entirely into the target, then the
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1648
  // remainder is compacted into the space itself and that space becomes the new
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1649
  // target.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1650
  SpaceId dst_space_id = old_space_id;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1651
  HeapWord* dst_space_end = old_space->end();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1652
  HeapWord** new_top_addr = _space_info[dst_space_id].new_top_addr();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1653
  for (unsigned int id = eden_space_id; id < last_space_id; ++id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
    const MutableSpace* space = _space_info[id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
    const size_t live = pointer_delta(_space_info[id].new_top(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
                                      space->bottom());
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1657
    const size_t available = pointer_delta(dst_space_end, *new_top_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1658
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1659
    NOT_PRODUCT(summary_phase_msg(dst_space_id, *new_top_addr, dst_space_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1660
                                  SpaceId(id), space->bottom(), space->top());)
974
6bbfda0c2a55 6724367: par compact could clear less young gen summary data
jcoomes
parents: 973
diff changeset
  1661
    if (live > 0 && live <= available) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
      // All the live data will fit.
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1663
      bool done = _summary_data.summarize(_space_info[id].split_info(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1664
                                          space->bottom(), space->top(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1665
                                          NULL,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1666
                                          *new_top_addr, dst_space_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1667
                                          new_top_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1668
      assert(done, "space must fit into old gen");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1669
974
6bbfda0c2a55 6724367: par compact could clear less young gen summary data
jcoomes
parents: 973
diff changeset
  1670
      // Reset the new_top value for the space.
6bbfda0c2a55 6724367: par compact could clear less young gen summary data
jcoomes
parents: 973
diff changeset
  1671
      _space_info[id].set_new_top(space->bottom());
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1672
    } else if (live > 0) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1673
      // Attempt to fit part of the source space into the target space.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1674
      HeapWord* next_src_addr = NULL;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1675
      bool done = _summary_data.summarize(_space_info[id].split_info(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1676
                                          space->bottom(), space->top(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1677
                                          &next_src_addr,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1678
                                          *new_top_addr, dst_space_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1679
                                          new_top_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1680
      assert(!done, "space should not fit into old gen");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1681
      assert(next_src_addr != NULL, "sanity");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1682
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1683
      // The source space becomes the new target, so the remainder is compacted
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1684
      // within the space itself.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1685
      dst_space_id = SpaceId(id);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1686
      dst_space_end = space->end();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1687
      new_top_addr = _space_info[id].new_top_addr();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1688
      NOT_PRODUCT(summary_phase_msg(dst_space_id,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1689
                                    space->bottom(), dst_space_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1690
                                    SpaceId(id), next_src_addr, space->top());)
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1691
      done = _summary_data.summarize(_space_info[id].split_info(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1692
                                     next_src_addr, space->top(),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1693
                                     NULL,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1694
                                     space->bottom(), dst_space_end,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1695
                                     new_top_addr);
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1696
      assert(done, "space must fit when compacted into itself");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  1697
      assert(*new_top_addr <= space->top(), "usage should not grow");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  if (TraceParallelOldGCSummaryPhase) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
    tty->print_cr("summary_phase:  after final summarization");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
    Universe::print();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  1704
    NOT_PRODUCT(print_region_ranges());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
    if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
      NOT_PRODUCT(print_generic_summary_data(_summary_data, _space_info));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
// This method should contain all heap-specific policy for invoking a full
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
// collection.  invoke_no_policy() will only attempt to compact the heap; it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
// will do nothing further.  If we need to bail out for policy reasons, scavenge
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
// before full gc, or any other specialized behavior, it needs to be added here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
// Note that this method should only be called from the vm_thread while at a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
// safepoint.
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1718
//
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1719
// Note that the all_soft_refs_clear flag in the collector policy
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1720
// may be true because this method can be called without intervening
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1721
// activity.  For example when the heap space is tight and full measure
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1722
// are being taken to free space.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
void PSParallelCompact::invoke(bool maximum_heap_compaction) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  assert(SafepointSynchronize::is_at_safepoint(), "should be at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  assert(Thread::current() == (Thread*)VMThread::vm_thread(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
         "should be in vm thread");
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1727
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  1728
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  GCCause::Cause gc_cause = heap->gc_cause();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
  assert(!heap->is_gc_active(), "not reentrant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
  PSAdaptiveSizePolicy* policy = heap->size_policy();
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1733
  IsGCActiveMark mark;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1734
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1735
  if (ScavengeBeforeFullGC) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1736
    PSScavenge::invoke_no_policy();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
  }
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1738
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1739
  const bool clear_all_soft_refs =
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1740
    heap->collector_policy()->should_clear_all_soft_refs();
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1741
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1742
  PSParallelCompact::invoke_no_policy(clear_all_soft_refs ||
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1743
                                      maximum_heap_compaction);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
// This method contains no policy. You should probably
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
// be calling invoke() instead.
11757
cdf6204b114a 7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents: 11636
diff changeset
  1748
bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
  assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
  assert(ref_processor() != NULL, "Sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
386
7f121b1192f2 6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents: 1
diff changeset
  1752
  if (GC_locker::check_active_before_gc()) {
11757
cdf6204b114a 7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents: 11636
diff changeset
  1753
    return false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  1756
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1757
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  1758
  GCIdMark gc_id_mark;
21767
41eaa9a17059 8028128: Add a type safe alternative for working with counter based data
mgronlun
parents: 20317
diff changeset
  1759
  _gc_timer.register_gc_start();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1760
  _gc_tracer.report_gc_start(heap->gc_cause(), _gc_timer.gc_start());
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1761
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
  TimeStamp marking_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
  TimeStamp compaction_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
  TimeStamp collection_exit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  GCCause::Cause gc_cause = heap->gc_cause();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
  PSYoungGen* young_gen = heap->young_gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
  PSOldGen* old_gen = heap->old_gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
  PSAdaptiveSizePolicy* size_policy = heap->size_policy();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1771
  // The scope of casr should end after code that can change
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1772
  // CollectorPolicy::_should_clear_all_soft_refs.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1773
  ClearedAllSoftRefs casr(maximum_heap_compaction,
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1774
                          heap->collector_policy());
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 5076
diff changeset
  1775
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1776
  if (ZapUnusedHeapArea) {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1777
    // Save information needed to minimize mangling
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1778
    heap->record_gen_tops_before_GC();
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1779
  }
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1780
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1781
  heap->pre_full_gc_dump(&_gc_timer);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2010
diff changeset
  1782
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
  _print_phases = PrintGCDetails && PrintParallelOldGCPhaseTimes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
  // Make sure data structures are sane, make the heap parsable, and do other
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  // miscellaneous bookkeeping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
  PreGCValues pre_gc_values;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
  pre_compact(&pre_gc_values);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
756
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1790
  // Get the compaction manager reserved for the VM thread.
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1791
  ParCompactionManager* const vmthread_cm =
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1792
    ParCompactionManager::manager_array(gc_task_manager()->workers());
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1793
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  // Place after pre_compact() where the number of invocations is incremented.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  AdaptiveSizePolicyOutput(size_policy, heap->total_collections());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
    HandleMark hm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1801
    // Set the number of GC threads to be used in this collection
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1802
    gc_task_manager()->set_active_gang();
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1803
    gc_task_manager()->task_idle_workers();
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1804
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
    TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  1806
    GCTraceTime t1(GCCauseString("Full GC", gc_cause), PrintGC, !PrintGCDetails, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
    TraceCollectorStats tcs(counters());
9623
151c0b638488 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents: 9178
diff changeset
  1808
    TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24845
diff changeset
  1810
    if (TraceOldGenTime) accumulated_time()->start();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
    // Let the size policy know we're starting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1813
    size_policy->major_collection_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
    CodeCache::gc_prologue();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1816
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1817
    COMPILER2_PRESENT(DerivedPointerTable::clear());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
28212
647b7d0efb88 8066827: Remove ReferenceProcessor::clean_up_discovered_references()
kbarrett
parents: 27887
diff changeset
  1819
    ref_processor()->enable_discovery();
1610
5dddd195cc86 6778647: snap(), snap_policy() should be renamed setup(), setup_policy()
ysr
parents: 1606
diff changeset
  1820
    ref_processor()->setup_policy(maximum_heap_compaction);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
    bool marked_for_unloading = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
    marking_start.update();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1825
    marking_phase(vmthread_cm, maximum_heap_compaction, &_gc_tracer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
12630
ddf6ee008138 7166894: Add gc cause to GC logging for all collectors
brutisso
parents: 11757
diff changeset
  1827
    bool max_on_system_gc = UseMaximumCompactionOnSystemGC
31032
8e72621ca186 8072913: [REDO] GCCause should distinguish jcmd GC.run from System.gc()
ysuenaga
parents: 30876
diff changeset
  1828
      && GCCause::is_user_requested_gc(gc_cause);
756
dc1ba65c5d1e 6676016: ParallelOldGC leaks memory
jcoomes
parents: 389
diff changeset
  1829
    summary_phase(vmthread_cm, maximum_heap_compaction || max_on_system_gc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
    COMPILER2_PRESENT(assert(DerivedPointerTable::is_active(), "Sanity"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
    COMPILER2_PRESENT(DerivedPointerTable::set_active(false));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
    // adjust_roots() updates Universe::_intArrayKlassObj which is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
    // needed by the compaction for filling holes in the dense prefix.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
    adjust_roots();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
    compaction_start.update();
9178
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  1839
    compact();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
    // Reset the mark bitmap, summary data, and do other bookkeeping.  Must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
    // done before resizing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
    post_compact();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
    // Let the size policy know we're done
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
    size_policy->major_collection_end(old_gen->used_in_bytes(), gc_cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
    if (UseAdaptiveSizePolicy) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
      if (PrintAdaptiveSizePolicy) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
        gclog_or_tty->print("AdaptiveSizeStart: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
        gclog_or_tty->stamp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
        gclog_or_tty->print_cr(" collection: %d ",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
                       heap->total_collections());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
        if (Verbose) {
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23854
diff changeset
  1855
          gclog_or_tty->print("old_gen_capacity: " SIZE_FORMAT
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23854
diff changeset
  1856
            " young_gen_capacity: " SIZE_FORMAT,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1857
            old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
      // Don't check if the size_policy is ready here.  Let
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
      // the size_policy check that internally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
      if (UseAdaptiveGenerationSizePolicyAtMajorCollection &&
31634
0aa645cd8cc3 7012980: PSOldGen is increased if there is no space in Metaspace
jmasa
parents: 31330
diff changeset
  1864
          AdaptiveSizePolicy::should_update_promo_stats(gc_cause)) {
23226
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1865
        // Swap the survivor spaces if from_space is empty. The
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1866
        // resize_young_gen() called below is normally used after
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1867
        // a successful young GC and swapping of survivor spaces;
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1868
        // otherwise, it will fail to resize the young gen with
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1869
        // the current implementation.
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1870
        if (young_gen->from_space()->is_empty()) {
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1871
          young_gen->from_space()->clear(SpaceDecorator::Mangle);
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1872
          young_gen->swap_spaces();
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1873
        }
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1874
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
        // Calculate optimal free space amounts
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
        assert(young_gen->max_size() >
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
          young_gen->from_space()->capacity_in_bytes() +
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
          young_gen->to_space()->capacity_in_bytes(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
          "Sizes of space in young gen are out-of-bounds");
17393
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1880
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1881
        size_t young_live = young_gen->used_in_bytes();
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1882
        size_t eden_live = young_gen->eden_space()->used_in_bytes();
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1883
        size_t old_live = old_gen->used_in_bytes();
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1884
        size_t cur_eden = young_gen->eden_space()->capacity_in_bytes();
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1885
        size_t max_old_gen_size = old_gen->max_gen_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
        size_t max_eden_size = young_gen->max_size() -
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
          young_gen->from_space()->capacity_in_bytes() -
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
          young_gen->to_space()->capacity_in_bytes();
17393
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1889
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1890
        // Used for diagnostics
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1891
        size_policy->clear_generation_free_space_flags();
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1892
17842
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1893
        size_policy->compute_generations_free_space(young_live,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1894
                                                    eden_live,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1895
                                                    old_live,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1896
                                                    cur_eden,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1897
                                                    max_old_gen_size,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1898
                                                    max_eden_size,
0d11fa49f81f 8007762: Rename a bunch of methods in size policy across collectors
tamao
parents: 17627
diff changeset
  1899
                                                    true /* full gc*/);
17393
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1900
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1901
        size_policy->check_gc_overhead_limit(young_live,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1902
                                             eden_live,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1903
                                             max_old_gen_size,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1904
                                             max_eden_size,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1905
                                             true /* full gc*/,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1906
                                             gc_cause,
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1907
                                             heap->collector_policy());
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1908
7e99f263902c 8007763: Refactoring: split up compute_generation_free_space() into two functions for class PSAdaptiveSizePolicy
tamao
parents: 17390
diff changeset
  1909
        size_policy->decay_supplemental_growth(true /* full gc*/);
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1910
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1911
        heap->resize_old_gen(
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1912
          size_policy->calculated_old_free_size_in_bytes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
23226
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1914
        heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(),
3a3de05bb757 7098155: Resize young gen at full collections for UseParallelGC
jmasa
parents: 22551
diff changeset
  1915
                               size_policy->calculated_survivor_size_in_bytes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
      if (PrintAdaptiveSizePolicy) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
        gclog_or_tty->print_cr("AdaptiveSizeStop: collection: %d ",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1919
                       heap->total_collections());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1920
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1921
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1922
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1923
    if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1924
      PSGCAdaptivePolicyCounters* const counters = heap->gc_policy_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1925
      counters->update_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1926
      counters->update_old_capacity(old_gen->capacity_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1927
      counters->update_young_capacity(young_gen->capacity_in_bytes());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1928
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1929
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1930
    heap->resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22221
diff changeset
  1932
    // Resize the metaspace capacity after a collection
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1933
    MetaspaceGC::compute_new_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1934
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24845
diff changeset
  1935
    if (TraceOldGenTime) accumulated_time()->stop();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1936
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1937
    if (PrintGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1938
      if (PrintGCDetails) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1939
        // No GC timestamp here.  This is after GC so it would be confusing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1940
        young_gen->print_used_change(pre_gc_values.young_gen_used());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1941
        old_gen->print_used_change(pre_gc_values.old_gen_used());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1942
        heap->print_heap_change(pre_gc_values.heap_used());
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1943
        MetaspaceAux::print_metaspace_change(pre_gc_values.metadata_used());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1944
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1945
        heap->print_heap_change(pre_gc_values.heap_used());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1946
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1947
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1948
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1949
    // Track memory usage and detect low memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1950
    MemoryService::track_memory_usage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1951
    heap->update_counters();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1952
    gc_task_manager()->release_idle_workers();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1953
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1954
6762
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1955
#ifdef ASSERT
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1956
  for (size_t i = 0; i < ParallelGCThreads + 1; ++i) {
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1957
    ParCompactionManager* const cm =
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1958
      ParCompactionManager::manager_array(int(i));
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1959
    assert(cm->marking_stack()->is_empty(),       "should be empty");
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  1960
    assert(ParCompactionManager::region_list(int(i))->is_empty(), "should be empty");
6762
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1961
  }
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1962
#endif // ASSERT
f8d1b560700e 6423256: GC stacks should use a better data structure
jcoomes
parents: 6759
diff changeset
  1963
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1964
  if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1965
    HandleMark hm;  // Discard invalid handles created during verification
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 17109
diff changeset
  1966
    Universe::verify(" VerifyAfterGC:");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1967
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1968
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1969
  // Re-verify object start arrays
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1970
  if (VerifyObjectStartArray &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1971
      VerifyAfterGC) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1972
    old_gen->verify_object_start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1973
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1974
971
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1975
  if (ZapUnusedHeapArea) {
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1976
    old_gen->object_space()->check_mangled_unused_area_complete();
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1977
  }
f0b20be4165d 6672698: mangle_unused_area() should not remangle the entire heap at each collection.
jmasa
parents: 756
diff changeset
  1978
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1979
  NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1980
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1981
  collection_exit.update();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1982
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11251
diff changeset
  1983
  heap->print_heap_after_gc();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1984
  heap->trace_heap_after_gc(&_gc_tracer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1985
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
  if (PrintGCTaskTimeStamps) {
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1987
    gclog_or_tty->print_cr("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " "
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  1988
                           JLONG_FORMAT,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
                           marking_start.ticks(), compaction_start.ticks(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
                           collection_exit.ticks());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1991
    gc_task_manager()->print_task_time_stamps();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
  }
2010
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1683
diff changeset
  1993
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  1994
  heap->post_full_gc_dump(&_gc_timer);
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2010
diff changeset
  1995
2010
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1683
diff changeset
  1996
#ifdef TRACESPINNING
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1683
diff changeset
  1997
  ParallelTaskTerminator::print_termination_counts();
c13462bbad17 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 1683
diff changeset
  1998
#endif
11757
cdf6204b114a 7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents: 11636
diff changeset
  1999
21767
41eaa9a17059 8028128: Add a type safe alternative for working with counter based data
mgronlun
parents: 20317
diff changeset
  2000
  _gc_timer.register_gc_end();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2001
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2002
  _gc_tracer.report_dense_prefix(dense_prefix(old_space_id));
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2003
  _gc_tracer.report_gc_end(_gc_timer.gc_end(), _gc_timer.time_partitions());
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2004
11757
cdf6204b114a 7146343: PS invoke methods should indicate the type of gc done
jcoomes
parents: 11636
diff changeset
  2005
  return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
bool PSParallelCompact::absorb_live_data_from_eden(PSAdaptiveSizePolicy* size_policy,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
                                             PSYoungGen* young_gen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2010
                                             PSOldGen* old_gen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  MutableSpace* const eden_space = young_gen->eden_space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
  assert(!eden_space->is_empty(), "eden must be non-empty");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  assert(young_gen->virtual_space()->alignment() ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2014
         old_gen->virtual_space()->alignment(), "alignments do not match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
  if (!(UseAdaptiveSizePolicy && UseAdaptiveGCBoundary)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
  // Both generations must be completely committed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
  if (young_gen->virtual_space()->uncommitted_size() != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2024
  if (old_gen->virtual_space()->uncommitted_size() != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2025
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
  // Figure out how much to take from eden.  Include the average amount promoted
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
  // in the total; otherwise the next young gen GC will simply bail out to a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2030
  // full GC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
  const size_t alignment = old_gen->virtual_space()->alignment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
  const size_t eden_used = eden_space->used_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
  const size_t promoted = (size_t)size_policy->avg_promoted()->padded_average();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
  const size_t absorb_size = align_size_up(eden_used + promoted, alignment);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
  const size_t eden_capacity = eden_space->capacity_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2037
  if (absorb_size >= eden_capacity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2038
    return false; // Must leave some space in eden.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2039
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
  const size_t new_young_size = young_gen->capacity_in_bytes() - absorb_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2042
  if (new_young_size < young_gen->min_gen_size()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
    return false; // Respect young gen minimum size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2044
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
  if (TraceAdaptiveGCBoundary && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2047
    gclog_or_tty->print(" absorbing " SIZE_FORMAT "K:  "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2048
                        "eden " SIZE_FORMAT "K->" SIZE_FORMAT "K "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
                        "from " SIZE_FORMAT "K, to " SIZE_FORMAT "K "
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
                        "young_gen " SIZE_FORMAT "K->" SIZE_FORMAT "K ",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
                        absorb_size / K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
                        eden_capacity / K, (eden_capacity - absorb_size) / K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
                        young_gen->from_space()->used_in_bytes() / K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2054
                        young_gen->to_space()->used_in_bytes() / K,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
                        young_gen->capacity_in_bytes() / K, new_young_size / K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
  // Fill the unused part of the old gen.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
  MutableSpace* const old_space = old_gen->object_space();
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2060
  HeapWord* const unused_start = old_space->top();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2061
  size_t const unused_words = pointer_delta(old_space->end(), unused_start);
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2062
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2063
  if (unused_words > 0) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2064
    if (unused_words < CollectedHeap::min_fill_size()) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2065
      return false;  // If the old gen cannot be filled, must give up.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2066
    }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2067
    CollectedHeap::fill_with_objects(unused_start, unused_words);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2070
  // Take the live data from eden and set both top and end in the old gen to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2071
  // eden top.  (Need to set end because reset_after_change() mangles the region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2072
  // from end to virtual_space->high() in debug builds).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
  HeapWord* const new_top = eden_space->top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
  old_gen->virtual_space()->expand_into(young_gen->virtual_space(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
                                        absorb_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
  young_gen->reset_after_change();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
  old_space->set_top(new_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
  old_space->set_end(new_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
  old_gen->reset_after_change();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
  // Update the object start array for the filler object and the data from eden.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2082
  ObjectStartArray* const start_array = old_gen->start_array();
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2083
  for (HeapWord* p = unused_start; p < new_top; p += oop(p)->size()) {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1610
diff changeset
  2084
    start_array->allocate_block(p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2085
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2086
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2087
  // Could update the promoted average here, but it is not typically updated at
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2088
  // full GCs and the value to use is unclear.  Something like
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2089
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2090
  // cur_promoted_avg + absorb_size / number_of_scavenges_since_last_full_gc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2092
  size_policy->set_bytes_absorbed_from_eden(absorb_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2093
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2094
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2096
GCTaskManager* const PSParallelCompact::gc_task_manager() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
  assert(ParallelScavengeHeap::gc_task_manager() != NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
    "shouldn't return NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2099
  return ParallelScavengeHeap::gc_task_manager();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2102
void PSParallelCompact::marking_phase(ParCompactionManager* cm,
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2103
                                      bool maximum_heap_compaction,
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2104
                                      ParallelOldTracer *gc_tracer) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2105
  // Recursively traverse all live objects and mark them
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2106
  GCTraceTime tm("marking phase", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2107
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  2108
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2109
  uint parallel_gc_threads = heap->gc_task_manager()->workers();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2110
  uint active_gc_threads = heap->gc_task_manager()->active_workers();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2111
  TaskQueueSetSuper* qset = ParCompactionManager::region_array();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2112
  ParallelTaskTerminator terminator(active_gc_threads, qset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2113
30556
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30555
diff changeset
  2114
  ParCompactionManager::MarkAndPushClosure mark_and_push_closure(cm);
750fee2bdb45 8078345: Move PSParallelCompact::mark_and_push to ParCompactionManager
stefank
parents: 30555
diff changeset
  2115
  ParCompactionManager::FollowStackClosure follow_stack_closure(cm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2117
  // Need new claim bits before marking starts.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2118
  ClassLoaderDataGraph::clear_claimed_marks();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2119
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
  {
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2121
    GCTraceTime tm_m("par mark", print_phases(), true, &_gc_timer);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2122
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2363
diff changeset
  2123
    ParallelScavengeHeap::ParStrongRootsScope psrs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
    GCTaskQueue* q = GCTaskQueue::create();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::universe));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::jni_handles));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
    // We scan the thread roots in parallel
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
    Threads::create_thread_roots_marking_tasks(q);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::object_synchronizer));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::flat_profiler));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::management));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::system_dictionary));
17844
28ca9179db98 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty
stefank
parents: 17842
diff changeset
  2135
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::class_loader_data));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::jvmti));
3908
24b55ad4c228 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 2363
diff changeset
  2137
    q->enqueue(new MarkFromRootsTask(MarkFromRootsTask::code_cache));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2139
    if (active_gc_threads > 1) {
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2140
      for (uint j = 0; j < active_gc_threads; j++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
        q->enqueue(new StealMarkingTask(&terminator));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2145
    gc_task_manager()->execute_and_wait(q);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
  // Process reference objects found during marking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
  {
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2150
    GCTraceTime tm_r("reference processing", print_phases(), true, &_gc_timer);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2151
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2152
    ReferenceProcessorStats stats;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
    if (ref_processor()->processing_is_mt()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
      RefProcTaskExecutor task_executor;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2155
      stats = ref_processor()->process_discovered_references(
1606
dcf9714addbe 6684579: SoftReference processing can be made more efficient
ysr
parents: 1408
diff changeset
  2156
        is_alive_closure(), &mark_and_push_closure, &follow_stack_closure,
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2157
        &task_executor, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
    } else {
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2159
      stats = ref_processor()->process_discovered_references(
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2160
        is_alive_closure(), &mark_and_push_closure, &follow_stack_closure, NULL,
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2161
        &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
    }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2163
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2164
    gc_tracer->report_gc_reference_stats(stats);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2167
  GCTraceTime tm_c("class unloading", print_phases(), true, &_gc_timer);
17114
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2168
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2169
  // This is the point where the entire marking should have completed.
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2170
  assert(cm->marking_stacks_empty(), "Marking should have completed");
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2171
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
  // Follow system dictionary roots and unload classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2173
  bool purged_class = SystemDictionary::do_unloading(is_alive_closure());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2174
17114
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2175
  // Unload nmethods.
13878
6e6a462a6cff 7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents: 13759
diff changeset
  2176
  CodeCache::do_unloading(is_alive_closure(), purged_class);
17114
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2177
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2178
  // Prune dead klasses from subklass/sibling/implementor lists.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2179
  Klass::clean_weak_klass_links(is_alive_closure());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2180
17114
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2181
  // Delete entries for dead interned strings.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2182
  StringTable::unlink(is_alive_closure());
17114
b341b4c63384 8013160: NPG: Remove unnecessary mark stack draining after CodeCache::do_unloading
stefank
parents: 17112
diff changeset
  2183
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
  2184
  // Clean up unreferenced symbols in symbol table.
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7918
diff changeset
  2185
  SymbolTable::unlink();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17851
diff changeset
  2186
  _gc_tracer.report_object_count_after_gc(is_alive_closure());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2188
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2189
// This should be moved to the shared markSweep code!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2190
class PSAlwaysTrueClosure: public BoolObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2191
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2192
  bool do_object_b(oop p) { return true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2193
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2194
static PSAlwaysTrueClosure always_true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2196
void PSParallelCompact::adjust_roots() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2197
  // Adjust the pointers to reflect the new locations
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2198
  GCTraceTime tm("adjust roots", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2199
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2200
  // Need new claim bits when tracing through and adjusting pointers.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2201
  ClassLoaderDataGraph::clear_claimed_marks();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2202
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2203
  // General strong roots.
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2204
  Universe::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2205
  JNIHandles::oops_do(adjust_pointer_closure());   // Global (strong) JNI handles
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2206
  CLDToOopClosure adjust_from_cld(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2207
  Threads::oops_do(adjust_pointer_closure(), &adjust_from_cld, NULL);
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2208
  ObjectSynchronizer::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2209
  FlatProfiler::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2210
  Management::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2211
  JvmtiExport::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2212
  SystemDictionary::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2213
  ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2214
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2215
  // Now adjust pointers in remaining weak roots.  (All of which should
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2216
  // have been cleared if they pointed to non-surviving objects.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2217
  // Global (weak) JNI handles
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2218
  JNIHandles::weak_oops_do(&always_true, adjust_pointer_closure());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2219
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
  2220
  CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
  2221
  CodeCache::blobs_do(&adjust_from_blobs);
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2222
  StringTable::oops_do(adjust_pointer_closure());
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2223
  ref_processor()->weak_oops_do(adjust_pointer_closure());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2224
  // Roots were visited so references into the young gen in roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2225
  // may have been scanned.  Process them also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
  // Should the reference processor have a span that excludes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
  // young gen objects?
17105
25b392a7740d 8012687: Remove unused is_root checks and closures
stefank
parents: 16685
diff changeset
  2228
  PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2231
void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2232
                                                      uint parallel_gc_threads)
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2233
{
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2234
  GCTraceTime tm("drain task setup", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2235
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2236
  // Find the threads that are active
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2237
  unsigned int which = 0;
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2238
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2239
  const uint task_count = MAX2(parallel_gc_threads, 1U);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2240
  for (uint j = 0; j < task_count; j++) {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5918
diff changeset
  2241
    q->enqueue(new DrainStacksCompactionTask(j));
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2242
    ParCompactionManager::verify_region_list_empty(j);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2243
    // Set the region stacks variables to "no" region stack values
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2244
    // so that they will be recognized and needing a region stack
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2245
    // in the stealing tasks if they do not get one by executing
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2246
    // a draining stack.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2247
    ParCompactionManager* cm = ParCompactionManager::manager_array(j);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2248
    cm->set_region_stack(NULL);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2249
    cm->set_region_stack_index((uint)max_uintx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2250
  }
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2251
  ParCompactionManager::reset_recycled_stack_index();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2253
  // Find all regions that are available (can be filled immediately) and
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
  // distribute them to the thread stacks.  The iteration is done in reverse
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2255
  // order (high to low) so the regions will be removed in ascending order.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
  const ParallelCompactData& sd = PSParallelCompact::summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2259
  size_t fillable_regions = 0;   // A count for diagnostic purposes.
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2260
  // A region index which corresponds to the tasks created above.
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2261
  // "which" must be 0 <= which < task_count
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2262
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2263
  which = 0;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2264
  // id + 1 is used to test termination so unsigned  can
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2265
  // be used with an old_space_id == 0.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2266
  for (unsigned int id = to_space_id; id + 1 > old_space_id; --id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
    SpaceInfo* const space_info = _space_info + id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
    MutableSpace* const space = space_info->space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
    HeapWord* const new_top = space_info->new_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2271
    const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2272
    const size_t end_region =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2273
      sd.addr_to_region_idx(sd.region_align_up(new_top));
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2274
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2275
    for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2276
      if (sd.region(cur)->claim_unsafe()) {
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2277
        ParCompactionManager::region_list_push(which, cur);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
        if (TraceParallelOldGCCompactionPhase && Verbose) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2280
          const size_t count_mod_8 = fillable_regions & 7;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
          if (count_mod_8 == 0) gclog_or_tty->print("fillable: ");
972
b86fd2f84aaf 6718283: existing uses of *_FORMAT_W() were broken by 6521491
jcoomes
parents: 971
diff changeset
  2282
          gclog_or_tty->print(" " SIZE_FORMAT_W(7), cur);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
          if (count_mod_8 == 7) gclog_or_tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2286
        NOT_PRODUCT(++fillable_regions;)
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2287
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2288
        // Assign regions to tasks in round-robin fashion.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
        if (++which == task_count) {
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2290
          assert(which <= parallel_gc_threads,
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2291
            "Inconsistent number of workers");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
          which = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
  if (TraceParallelOldGCCompactionPhase) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2299
    if (Verbose && (fillable_regions & 7) != 0) gclog_or_tty->cr();
24092
e274d864545a 8039743: Use correct format specifier to print size_t values and pointers in the GC code
stefank
parents: 23854
diff changeset
  2300
    gclog_or_tty->print_cr(SIZE_FORMAT " initially fillable regions", fillable_regions);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2301
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2302
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2303
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
#define PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING 4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
void PSParallelCompact::enqueue_dense_prefix_tasks(GCTaskQueue* q,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
                                                    uint parallel_gc_threads) {
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2308
  GCTraceTime tm("dense prefix task setup", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
  ParallelCompactData& sd = PSParallelCompact::summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2311
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2312
  // Iterate over all the spaces adding tasks for updating
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2313
  // regions in the dense prefix.  Assume that 1 gc thread
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
  // will work on opening the gaps and the remaining gc threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
  // will work on the dense prefix.
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2316
  unsigned int space_id;
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2317
  for (space_id = old_space_id; space_id < last_space_id; ++ space_id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
    HeapWord* const dense_prefix_end = _space_info[space_id].dense_prefix();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
    const MutableSpace* const space = _space_info[space_id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
    if (dense_prefix_end == space->bottom()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
      // There is no dense prefix for this space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2323
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2326
    // The dense prefix is before this region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2327
    size_t region_index_end_dense_prefix =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2328
        sd.addr_to_region_idx(dense_prefix_end);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2329
    RegionData* const dense_prefix_cp =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2330
      sd.region(region_index_end_dense_prefix);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
    assert(dense_prefix_end == space->end() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
           dense_prefix_cp->available() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
           dense_prefix_cp->claimed(),
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2334
           "The region after the dense prefix should always be ready to fill");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2335
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2336
    size_t region_index_start = sd.addr_to_region_idx(space->bottom());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
    // Is there dense prefix work?
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2339
    size_t total_dense_prefix_regions =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2340
      region_index_end_dense_prefix - region_index_start;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2341
    // How many regions of the dense prefix should be given to
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
    // each thread?
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2343
    if (total_dense_prefix_regions > 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
      uint tasks_for_dense_prefix = 1;
9178
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2345
      if (total_dense_prefix_regions <=
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2346
          (parallel_gc_threads * PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING)) {
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2347
        // Don't over partition.  This assumes that
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2348
        // PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING is a small integer value
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2349
        // so there are not many regions to process.
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2350
        tasks_for_dense_prefix = parallel_gc_threads;
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2351
      } else {
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2352
        // Over partition
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2353
        tasks_for_dense_prefix = parallel_gc_threads *
1a022d4f1bc3 6841742: par compact - remove unused/unsupported options
jcoomes
parents: 8688
diff changeset
  2354
          PAR_OLD_DENSE_PREFIX_OVER_PARTITIONING;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
      }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2356
      size_t regions_per_thread = total_dense_prefix_regions /
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
        tasks_for_dense_prefix;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2358
      // Give each thread at least 1 region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2359
      if (regions_per_thread == 0) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2360
        regions_per_thread = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
      for (uint k = 0; k < tasks_for_dense_prefix; k++) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2364
        if (region_index_start >= region_index_end_dense_prefix) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
        }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2367
        // region_index_end is not processed
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2368
        size_t region_index_end = MIN2(region_index_start + regions_per_thread,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2369
                                       region_index_end_dense_prefix);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2370
        q->enqueue(new UpdateDensePrefixTask(SpaceId(space_id),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2371
                                             region_index_start,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2372
                                             region_index_end));
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2373
        region_index_start = region_index_end;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
    // This gets any part of the dense prefix that did not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2377
    // fit evenly.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2378
    if (region_index_start < region_index_end_dense_prefix) {
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2379
      q->enqueue(new UpdateDensePrefixTask(SpaceId(space_id),
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2380
                                           region_index_start,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2381
                                           region_index_end_dense_prefix));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
    }
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2383
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2386
void PSParallelCompact::enqueue_region_stealing_tasks(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2387
                                     GCTaskQueue* q,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
                                     ParallelTaskTerminator* terminator_ptr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
                                     uint parallel_gc_threads) {
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2390
  GCTraceTime tm("steal task setup", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2392
  // Once a thread has drained it's stack, it should try to steal regions from
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
  // other threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
  if (parallel_gc_threads > 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
    for (uint j = 0; j < parallel_gc_threads; j++) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2396
      q->enqueue(new StealRegionCompactionTask(terminator_ptr));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2401
#ifdef ASSERT
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2402
// Write a histogram of the number of times the block table was filled for a
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2403
// region.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2404
void PSParallelCompact::write_block_fill_histogram(outputStream* const out)
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2405
{
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2406
  if (!TraceParallelOldGCCompactionPhase) return;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2407
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2408
  typedef ParallelCompactData::RegionData rd_t;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2409
  ParallelCompactData& sd = summary_data();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2410
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2411
  for (unsigned int id = old_space_id; id < last_space_id; ++id) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2412
    MutableSpace* const spc = _space_info[id].space();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2413
    if (spc->bottom() != spc->top()) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2414
      const rd_t* const beg = sd.addr_to_region_ptr(spc->bottom());
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2415
      HeapWord* const top_aligned_up = sd.region_align_up(spc->top());
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2416
      const rd_t* const end = sd.addr_to_region_ptr(top_aligned_up);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2417
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2418
      size_t histo[5] = { 0, 0, 0, 0, 0 };
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2419
      const size_t histo_len = sizeof(histo) / sizeof(size_t);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2420
      const size_t region_cnt = pointer_delta(end, beg, sizeof(rd_t));
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2421
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2422
      for (const rd_t* cur = beg; cur < end; ++cur) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2423
        ++histo[MIN2(cur->blocks_filled_count(), histo_len - 1)];
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2424
      }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2425
      out->print("%u %-4s" SIZE_FORMAT_W(5), id, space_names[id], region_cnt);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2426
      for (size_t i = 0; i < histo_len; ++i) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2427
        out->print(" " SIZE_FORMAT_W(5) " %5.1f%%",
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2428
                   histo[i], 100.0 * histo[i] / region_cnt);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2429
      }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2430
      out->cr();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2431
    }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2432
  }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2433
}
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2434
#endif // #ifdef ASSERT
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2435
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
void PSParallelCompact::compact() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
  // trace("5");
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2438
  GCTraceTime tm("compaction phase", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  2440
  ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
  PSOldGen* old_gen = heap->old_gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
  old_gen->start_array()->reset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
  uint parallel_gc_threads = heap->gc_task_manager()->workers();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2444
  uint active_gc_threads = heap->gc_task_manager()->active_workers();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2445
  TaskQueueSetSuper* qset = ParCompactionManager::region_array();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2446
  ParallelTaskTerminator terminator(active_gc_threads, qset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
  GCTaskQueue* q = GCTaskQueue::create();
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2449
  enqueue_region_draining_tasks(q, active_gc_threads);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2450
  enqueue_dense_prefix_tasks(q, active_gc_threads);
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2451
  enqueue_region_stealing_tasks(q, &terminator, active_gc_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
  {
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2454
    GCTraceTime tm_pc("par compact", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10670
diff changeset
  2456
    gc_task_manager()->execute_and_wait(q);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
#ifdef  ASSERT
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2459
    // Verify that all regions have been processed before the deferred updates.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2460
    for (unsigned int id = old_space_id; id < last_space_id; ++id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
      verify_complete(SpaceId(id));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2463
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2464
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2466
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2467
    // Update the deferred objects, if any.  Any compaction manager can be used.
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
  2468
    GCTraceTime tm_du("deferred updates", print_phases(), true, &_gc_timer);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2469
    ParCompactionManager* cm = ParCompactionManager::manager_array(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2470
    for (unsigned int id = old_space_id; id < last_space_id; ++id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
      update_deferred_objects(cm, SpaceId(id));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2472
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
  }
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2474
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2475
  DEBUG_ONLY(write_block_fill_histogram(gclog_or_tty));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2476
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2478
#ifdef  ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
void PSParallelCompact::verify_complete(SpaceId space_id) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2480
  // All Regions between space bottom() to new_top() should be marked as filled
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2481
  // and all Regions between new_top() and top() should be available (i.e.,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
  // should have been emptied).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
  ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
  SpaceInfo si = _space_info[space_id];
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2485
  HeapWord* new_top_addr = sd.region_align_up(si.new_top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2486
  HeapWord* old_top_addr = sd.region_align_up(si.space()->top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2487
  const size_t beg_region = sd.addr_to_region_idx(si.space()->bottom());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2488
  const size_t new_top_region = sd.addr_to_region_idx(new_top_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2489
  const size_t old_top_region = sd.addr_to_region_idx(old_top_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
  bool issued_a_warning = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2493
  size_t cur_region;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2494
  for (cur_region = beg_region; cur_region < new_top_region; ++cur_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2495
    const RegionData* const c = sd.region(cur_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
    if (!c->completed()) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2497
      warning("region " SIZE_FORMAT " not filled:  "
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  2498
              "destination_count=%u",
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2499
              cur_region, c->destination_count());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
      issued_a_warning = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2504
  for (cur_region = new_top_region; cur_region < old_top_region; ++cur_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2505
    const RegionData* const c = sd.region(cur_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
    if (!c->available()) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2507
      warning("region " SIZE_FORMAT " not empty:   "
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  2508
              "destination_count=%u",
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2509
              cur_region, c->destination_count());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
      issued_a_warning = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
  if (issued_a_warning) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2515
    print_region_ranges();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2520
inline void UpdateOnlyClosure::do_addr(HeapWord* addr) {
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2521
  _start_array->allocate_block(addr);
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2522
  compaction_manager()->update_contents(oop(addr));
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2523
}
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2524
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2525
// Update interior oops in the ranges of regions [beg_region, end_region).
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
PSParallelCompact::update_and_deadwood_in_dense_prefix(ParCompactionManager* cm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
                                                       SpaceId space_id,
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2529
                                                       size_t beg_region,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2530
                                                       size_t end_region) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
  ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
  ParMarkBitMap* const mbm = mark_bitmap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2534
  HeapWord* beg_addr = sd.region_to_addr(beg_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2535
  HeapWord* const end_addr = sd.region_to_addr(end_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2536
  assert(beg_region <= end_region, "bad region range");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
  assert(end_addr <= dense_prefix(space_id), "not in the dense prefix");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
#ifdef  ASSERT
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2540
  // Claim the regions to avoid triggering an assert when they are marked as
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
  // filled.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2542
  for (size_t claim_region = beg_region; claim_region < end_region; ++claim_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2543
    assert(sd.region(claim_region)->claim_unsafe(), "claim() failed");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
#endif  // #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
  if (beg_addr != space(space_id)->bottom()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
    // Find the first live object or block of dead space that *starts* in this
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2549
    // range of regions.  If a partial object crosses onto the region, skip it;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2550
    // it will be marked for 'deferred update' when the object head is
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2551
    // processed.  If dead space crosses onto the region, it is also skipped; it
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2552
    // will be filled when the prior region is processed.  If neither of those
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2553
    // apply, the first word in the region is the start of a live object or dead
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2554
    // space.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
    assert(beg_addr > space(space_id)->bottom(), "sanity");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2556
    const RegionData* const cp = sd.region(beg_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
    if (cp->partial_obj_size() != 0) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2558
      beg_addr = sd.partial_obj_end(beg_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
    } else if (dead_space_crosses_boundary(cp, mbm->addr_to_bit(beg_addr))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
      beg_addr = mbm->find_obj_beg(beg_addr, end_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
  if (beg_addr < end_addr) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2565
    // A live object or block of dead space starts in this range of Regions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
     HeapWord* const dense_prefix_end = dense_prefix(space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
    // Create closures and iterate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
    UpdateOnlyClosure update_closure(mbm, cm, space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
    FillClosure fill_closure(cm, space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
    ParMarkBitMap::IterationStatus status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
    status = mbm->iterate(&update_closure, &fill_closure, beg_addr, end_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
                          dense_prefix_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
    if (status == ParMarkBitMap::incomplete) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
      update_closure.do_addr(update_closure.source());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2579
  // Mark the regions as filled.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2580
  RegionData* const beg_cp = sd.region(beg_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2581
  RegionData* const end_cp = sd.region(end_region);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2582
  for (RegionData* cp = beg_cp; cp < end_cp; ++cp) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
    cp->set_completed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
// Return the SpaceId for the space containing addr.  If addr is not in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
// heap, last_space_id is returned.  In debug mode it expects the address to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
// in the heap and asserts such.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) {
30173
13cf7580b000 8077413: Avoid use of Universe::heap() inside collectors
pliden
parents: 30150
diff changeset
  2591
  assert(ParallelScavengeHeap::heap()->is_in_reserved(addr), "addr not in the heap");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2593
  for (unsigned int id = old_space_id; id < last_space_id; ++id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
    if (_space_info[id].space()->contains(addr)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
      return SpaceId(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
  assert(false, "no space contains the addr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
  return last_space_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
void PSParallelCompact::update_deferred_objects(ParCompactionManager* cm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
                                                SpaceId id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
  assert(id < last_space_id, "bad space id");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2606
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
  ParallelCompactData& sd = summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
  const SpaceInfo* const space_info = _space_info + id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
  ObjectStartArray* const start_array = space_info->start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2611
  const MutableSpace* const space = space_info->space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
  assert(space_info->dense_prefix() >= space->bottom(), "dense_prefix not set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
  HeapWord* const beg_addr = space_info->dense_prefix();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2614
  HeapWord* const end_addr = sd.region_align_up(space_info->new_top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2615
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2616
  const RegionData* const beg_region = sd.addr_to_region_ptr(beg_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2617
  const RegionData* const end_region = sd.addr_to_region_ptr(end_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2618
  const RegionData* cur_region;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2619
  for (cur_region = beg_region; cur_region < end_region; ++cur_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2620
    HeapWord* const addr = cur_region->deferred_obj_addr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2621
    if (addr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
      if (start_array != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
        start_array->allocate_block(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
      }
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  2625
      cm->update_contents(oop(addr));
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32623
diff changeset
  2626
      assert(oop(addr)->is_oop_or_null(), "Expected an oop or NULL at " PTR_FORMAT, p2i(oop(addr)));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2631
// Skip over count live words starting from beg, and return the address of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
// next live word.  Unless marked, the word corresponding to beg is assumed to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
// be dead.  Callers must either ensure beg does not correspond to the middle of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
// an object, or account for those live words in some other way.  Callers must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
// also ensure that there are enough live words in the range [beg, end) to skip.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
HeapWord*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
PSParallelCompact::skip_live_words(HeapWord* beg, HeapWord* end, size_t count)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
  assert(count > 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
  ParMarkBitMap* m = mark_bitmap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
  idx_t bits_to_skip = m->words_to_bits(count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
  idx_t cur_beg = m->addr_to_bit(beg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2644
  const idx_t search_end = BitMap::word_align_up(m->addr_to_bit(end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2645
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2646
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2647
    cur_beg = m->find_obj_beg(cur_beg, search_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2648
    idx_t cur_end = m->find_obj_end(cur_beg, search_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2649
    const size_t obj_bits = cur_end - cur_beg + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2650
    if (obj_bits > bits_to_skip) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2651
      return m->bit_to_addr(cur_beg + bits_to_skip);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
    bits_to_skip -= obj_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2654
    cur_beg = cur_end + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
  } while (bits_to_skip > 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2656
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
  // Skipping the desired number of words landed just past the end of an object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
  // Find the start of the next object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
  cur_beg = m->find_obj_beg(cur_beg, search_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
  assert(cur_beg < m->addr_to_bit(end), "not enough live words to skip");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
  return m->bit_to_addr(cur_beg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2664
HeapWord* PSParallelCompact::first_src_addr(HeapWord* const dest_addr,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2665
                                            SpaceId src_space_id,
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2666
                                            size_t src_region_idx)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
{
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2668
  assert(summary_data().is_region_aligned(dest_addr), "not aligned");
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2670
  const SplitInfo& split_info = _space_info[src_space_id].split_info();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2671
  if (split_info.dest_region_addr() == dest_addr) {
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2672
    // The partial object ending at the split point contains the first word to
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2673
    // be copied to dest_addr.
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2674
    return split_info.first_src_addr();
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2675
  }
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2676
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2677
  const ParallelCompactData& sd = summary_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
  ParMarkBitMap* const bitmap = mark_bitmap();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2679
  const size_t RegionSize = ParallelCompactData::RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2680
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2681
  assert(sd.is_region_aligned(dest_addr), "not aligned");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2682
  const RegionData* const src_region_ptr = sd.region(src_region_idx);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2683
  const size_t partial_obj_size = src_region_ptr->partial_obj_size();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2684
  HeapWord* const src_region_destination = src_region_ptr->destination();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2685
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2686
  assert(dest_addr >= src_region_destination, "wrong src region");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2687
  assert(src_region_ptr->data_size() > 0, "src region cannot be empty");
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2688
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2689
  HeapWord* const src_region_beg = sd.region_to_addr(src_region_idx);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2690
  HeapWord* const src_region_end = src_region_beg + RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2691
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2692
  HeapWord* addr = src_region_beg;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2693
  if (dest_addr == src_region_destination) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2694
    // Return the first live word in the source region.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
    if (partial_obj_size == 0) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2696
      addr = bitmap->find_obj_beg(addr, src_region_end);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2697
      assert(addr < src_region_end, "no objects start in src region");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
    return addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
  // Must skip some live data.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2703
  size_t words_to_skip = dest_addr - src_region_destination;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2704
  assert(src_region_ptr->data_size() > words_to_skip, "wrong src region");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2706
  if (partial_obj_size >= words_to_skip) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
    // All the live words to skip are part of the partial object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
    addr += words_to_skip;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
    if (partial_obj_size == words_to_skip) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
      // Find the first live word past the partial object.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2711
      addr = bitmap->find_obj_beg(addr, src_region_end);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2712
      assert(addr < src_region_end, "wrong src region");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
    return addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
  // Skip over the partial object (if any).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
  if (partial_obj_size != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
    words_to_skip -= partial_obj_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
    addr += partial_obj_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2723
  // Skip over live words due to objects that start in the region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2724
  addr = skip_live_words(addr, src_region_end, words_to_skip);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2725
  assert(addr < src_region_end, "wrong src region");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  return addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2729
void PSParallelCompact::decrement_destination_counts(ParCompactionManager* cm,
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2730
                                                     SpaceId src_space_id,
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2731
                                                     size_t beg_region,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
                                                     HeapWord* end_addr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2733
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2734
  ParallelCompactData& sd = summary_data();
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2735
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2736
#ifdef ASSERT
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2737
  MutableSpace* const src_space = _space_info[src_space_id].space();
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2738
  HeapWord* const beg_addr = sd.region_to_addr(beg_region);
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2739
  assert(src_space->contains(beg_addr) || beg_addr == src_space->end(),
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2740
         "src_space_id does not match beg_addr");
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2741
  assert(src_space->contains(end_addr) || end_addr == src_space->end(),
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2742
         "src_space_id does not match end_addr");
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2743
#endif // #ifdef ASSERT
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2744
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2745
  RegionData* const beg = sd.region(beg_region);
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2746
  RegionData* const end = sd.addr_to_region_ptr(sd.region_align_up(end_addr));
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2747
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2748
  // Regions up to new_top() are enqueued if they become available.
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2749
  HeapWord* const new_top = _space_info[src_space_id].new_top();
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2750
  RegionData* const enqueue_end =
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2751
    sd.addr_to_region_ptr(sd.region_align_up(new_top));
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2752
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2753
  for (RegionData* cur = beg; cur < end; ++cur) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2754
    assert(cur->data_size() > 0, "region must have live data");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
    cur->decrement_destination_count();
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2756
    if (cur < enqueue_end && cur->available() && cur->claim()) {
5918
73b96456819a 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 5702
diff changeset
  2757
      cm->push_region(sd.region(cur));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2759
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2760
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2762
size_t PSParallelCompact::next_src_region(MoveAndUpdateClosure& closure,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2763
                                          SpaceId& src_space_id,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2764
                                          HeapWord*& src_space_top,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2765
                                          HeapWord* end_addr)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
{
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2767
  typedef ParallelCompactData::RegionData RegionData;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
  ParallelCompactData& sd = PSParallelCompact::summary_data();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2770
  const size_t region_size = ParallelCompactData::RegionSize;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2771
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2772
  size_t src_region_idx = 0;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2773
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2774
  // Skip empty regions (if any) up to the top of the space.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2775
  HeapWord* const src_aligned_up = sd.region_align_up(end_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2776
  RegionData* src_region_ptr = sd.addr_to_region_ptr(src_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2777
  HeapWord* const top_aligned_up = sd.region_align_up(src_space_top);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2778
  const RegionData* const top_region_ptr =
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2779
    sd.addr_to_region_ptr(top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2780
  while (src_region_ptr < top_region_ptr && src_region_ptr->data_size() == 0) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2781
    ++src_region_ptr;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2782
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2783
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2784
  if (src_region_ptr < top_region_ptr) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2785
    // The next source region is in the current space.  Update src_region_idx
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2786
    // and the source address to match src_region_ptr.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2787
    src_region_idx = sd.region(src_region_ptr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2788
    HeapWord* const src_region_addr = sd.region_to_addr(src_region_idx);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2789
    if (src_region_addr > closure.source()) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2790
      closure.set_source(src_region_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
    }
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2792
    return src_region_idx;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2795
  // Switch to a new source space and find the first non-empty region.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
  unsigned int space_id = src_space_id + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2797
  assert(space_id < last_space_id, "not enough spaces");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2798
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
  HeapWord* const destination = closure.destination();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2802
    MutableSpace* space = _space_info[space_id].space();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2803
    HeapWord* const bottom = space->bottom();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2804
    const RegionData* const bottom_cp = sd.addr_to_region_ptr(bottom);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2805
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2806
    // Iterate over the spaces that do not compact into themselves.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2807
    if (bottom_cp->destination() != bottom) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2808
      HeapWord* const top_aligned_up = sd.region_align_up(space->top());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2809
      const RegionData* const top_cp = sd.addr_to_region_ptr(top_aligned_up);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2810
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2811
      for (const RegionData* src_cp = bottom_cp; src_cp < top_cp; ++src_cp) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2812
        if (src_cp->live_obj_size() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2813
          // Found it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2814
          assert(src_cp->destination() == destination,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2815
                 "first live obj in the space must match the destination");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2816
          assert(src_cp->partial_obj_size() == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2817
                 "a space cannot begin with a partial obj");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2818
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2819
          src_space_id = SpaceId(space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2820
          src_space_top = space->top();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2821
          const size_t src_region_idx = sd.region(src_cp);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2822
          closure.set_source(sd.region_to_addr(src_region_idx));
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2823
          return src_region_idx;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2824
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
          assert(src_cp->data_size() == 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2826
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2827
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2829
  } while (++space_id < last_space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2830
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2831
  assert(false, "no source region was found");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2833
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2835
void PSParallelCompact::fill_region(ParCompactionManager* cm, size_t region_idx)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
  typedef ParMarkBitMap::IterationStatus IterationStatus;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2838
  const size_t RegionSize = ParallelCompactData::RegionSize;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
  ParMarkBitMap* const bitmap = mark_bitmap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
  ParallelCompactData& sd = summary_data();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2841
  RegionData* const region_ptr = sd.region(region_idx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
  // Get the items needed to construct the closure.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2844
  HeapWord* dest_addr = sd.region_to_addr(region_idx);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
  SpaceId dest_space_id = space_id(dest_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
  ObjectStartArray* start_array = _space_info[dest_space_id].start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
  HeapWord* new_top = _space_info[dest_space_id].new_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
  assert(dest_addr < new_top, "sanity");
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2849
  const size_t words = MIN2(pointer_delta(new_top, dest_addr), RegionSize);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2850
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2851
  // Get the source region and related info.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2852
  size_t src_region_idx = region_ptr->source_region();
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2853
  SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
  HeapWord* src_space_top = _space_info[src_space_id].space()->top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2855
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
  MoveAndUpdateClosure closure(bitmap, cm, start_array, dest_addr, words);
1669
c921639400dd 6765745: par compact - allow young gen spaces to be split
jcoomes
parents: 1668
diff changeset
  2857
  closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx));
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2858
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2859
  // Adjust src_region_idx to prepare for decrementing destination counts (the
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2860
  // destination count is not decremented when a region is copied to itself).
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2861
  if (src_region_idx == region_idx) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2862
    src_region_idx += 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2863
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2864
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2865
  if (bitmap->is_unmarked(closure.source())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2866
    // The first source word is in the middle of an object; copy the remainder
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2867
    // of the object or as much as will fit.  The fact that pointer updates were
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2868
    // deferred will be noted when the object header is processed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2869
    HeapWord* const old_src_addr = closure.source();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2870
    closure.copy_partial_obj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2871
    if (closure.is_full()) {
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2872
      decrement_destination_counts(cm, src_space_id, src_region_idx,
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2873
                                   closure.source());
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2874
      region_ptr->set_deferred_obj_addr(NULL);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2875
      region_ptr->set_completed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2876
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2877
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2878
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2879
    HeapWord* const end_addr = sd.region_align_down(closure.source());
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2880
    if (sd.region_align_down(old_src_addr) != end_addr) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2881
      // The partial object was copied from more than one source region.
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2882
      decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2883
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2884
      // Move to the next source region, possibly switching spaces as well.  All
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2885
      // args except end_addr may be modified.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2886
      src_region_idx = next_src_region(closure, src_space_id, src_space_top,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2887
                                       end_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2888
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2889
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2890
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2891
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2892
    HeapWord* const cur_addr = closure.source();
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2893
    HeapWord* const end_addr = MIN2(sd.region_align_up(cur_addr + 1),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2894
                                    src_space_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2895
    IterationStatus status = bitmap->iterate(&closure, cur_addr, end_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2896
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2897
    if (status == ParMarkBitMap::incomplete) {
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2898
      // The last obj that starts in the source region does not end in the
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2899
      // region.
5402
c51fd0c1d005 6888953: some calls to function-like macros are missing semicolons
jcoomes
parents: 5343
diff changeset
  2900
      assert(closure.source() < end_addr, "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2901
      HeapWord* const obj_beg = closure.source();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2902
      HeapWord* const range_end = MIN2(obj_beg + closure.words_remaining(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2903
                                       src_space_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2904
      HeapWord* const obj_end = bitmap->find_obj_end(obj_beg, range_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2905
      if (obj_end < range_end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2906
        // The end was found; the entire object will fit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2907
        status = closure.do_addr(obj_beg, bitmap->obj_size(obj_beg, obj_end));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2908
        assert(status != ParMarkBitMap::would_overflow, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2909
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
        // The end was not found; the object will not fit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
        assert(range_end < src_space_top, "obj cannot cross space boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
        status = ParMarkBitMap::would_overflow;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
    if (status == ParMarkBitMap::would_overflow) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
      // The last object did not fit.  Note that interior oop updates were
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2918
      // deferred, then copy enough of the object to fill the region.
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2919
      region_ptr->set_deferred_obj_addr(closure.destination());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
      status = closure.copy_until_full(); // copies from closure.source()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2922
      decrement_destination_counts(cm, src_space_id, src_region_idx,
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2923
                                   closure.source());
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2924
      region_ptr->set_completed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
    if (status == ParMarkBitMap::full) {
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2929
      decrement_destination_counts(cm, src_space_id, src_region_idx,
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2930
                                   closure.source());
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2931
      region_ptr->set_deferred_obj_addr(NULL);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2932
      region_ptr->set_completed();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  2936
    decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2937
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2938
    // Move to the next source region, possibly switching spaces as well.  All
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
    // args except end_addr may be modified.
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2940
    src_region_idx = next_src_region(closure, src_space_id, src_space_top,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  2941
                                     end_addr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
  } while (true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
17851
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2945
void PSParallelCompact::fill_blocks(size_t region_idx)
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2946
{
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2947
  // Fill in the block table elements for the specified region.  Each block
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2948
  // table element holds the number of live words in the region that are to the
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2949
  // left of the first object that starts in the block.  Thus only blocks in
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2950
  // which an object starts need to be filled.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2951
  //
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2952
  // The algorithm scans the section of the bitmap that corresponds to the
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2953
  // region, keeping a running total of the live words.  When an object start is
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2954
  // found, if it's the first to start in the block that contains it, the
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2955
  // current total is written to the block table element.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2956
  const size_t Log2BlockSize = ParallelCompactData::Log2BlockSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2957
  const size_t Log2RegionSize = ParallelCompactData::Log2RegionSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2958
  const size_t RegionSize = ParallelCompactData::RegionSize;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2959
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2960
  ParallelCompactData& sd = summary_data();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2961
  const size_t partial_obj_size = sd.region(region_idx)->partial_obj_size();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2962
  if (partial_obj_size >= RegionSize) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2963
    return; // No objects start in this region.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2964
  }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2965
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2966
  // Ensure the first loop iteration decides that the block has changed.
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2967
  size_t cur_block = sd.block_count();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2968
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2969
  const ParMarkBitMap* const bitmap = mark_bitmap();
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2970
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2971
  const size_t Log2BitsPerBlock = Log2BlockSize - LogMinObjAlignment;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2972
  assert((size_t)1 << Log2BitsPerBlock ==
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2973
         bitmap->words_to_bits(ParallelCompactData::BlockSize), "sanity");
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2974
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2975
  size_t beg_bit = bitmap->words_to_bits(region_idx << Log2RegionSize);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2976
  const size_t range_end = beg_bit + bitmap->words_to_bits(RegionSize);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2977
  size_t live_bits = bitmap->words_to_bits(partial_obj_size);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2978
  beg_bit = bitmap->find_obj_beg(beg_bit + live_bits, range_end);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2979
  while (beg_bit < range_end) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2980
    const size_t new_block = beg_bit >> Log2BitsPerBlock;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2981
    if (new_block != cur_block) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2982
      cur_block = new_block;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2983
      sd.block(cur_block)->set_offset(bitmap->bits_to_words(live_bits));
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2984
    }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2985
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2986
    const size_t end_bit = bitmap->find_obj_end(beg_bit, range_end);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2987
    if (end_bit < range_end - 1) {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2988
      live_bits += end_bit - beg_bit + 1;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2989
      beg_bit = bitmap->find_obj_beg(end_bit + 1, range_end);
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2990
    } else {
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2991
      return;
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2992
    }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2993
  }
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2994
}
04e698940f8a 6725714: par compact - add a table to speed up bitmap searches
jcoomes
parents: 17844
diff changeset
  2995
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
void
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
PSParallelCompact::move_and_update(ParCompactionManager* cm, SpaceId space_id) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
  const MutableSpace* sp = space(space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2999
  if (sp->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3003
  ParallelCompactData& sd = PSParallelCompact::summary_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
  ParMarkBitMap* const bitmap = mark_bitmap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
  HeapWord* const dp_addr = dense_prefix(space_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
  HeapWord* beg_addr = sp->bottom();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
  HeapWord* end_addr = sp->top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
  assert(beg_addr <= dp_addr && dp_addr <= end_addr, "bad dense prefix");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3011
  const size_t beg_region = sd.addr_to_region_idx(beg_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3012
  const size_t dp_region = sd.addr_to_region_idx(dp_addr);
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3013
  if (beg_region < dp_region) {
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3014
    update_and_deadwood_in_dense_prefix(cm, space_id, beg_region, dp_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3015
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3016
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3017
  // The destination of the first live object that starts in the region is one
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3018
  // past the end of the partial object entering the region (if any).
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1406
diff changeset
  3019
  HeapWord* const dest_addr = sd.partial_obj_end(dp_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
  HeapWord* const new_top = _space_info[space_id].new_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
  assert(new_top >= dest_addr, "bad new_top value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
  const size_t words = pointer_delta(new_top, dest_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3024
  if (words > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
    ObjectStartArray* start_array = _space_info[space_id].start_array();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
    MoveAndUpdateClosure closure(bitmap, cm, start_array, dest_addr, words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
    ParMarkBitMap::IterationStatus status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
    status = bitmap->iterate(&closure, dest_addr, end_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
    assert(status == ParMarkBitMap::full, "iteration not complete");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
    assert(bitmap->find_obj_beg(closure.source(), end_addr) == end_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
           "live objects skipped because closure is full");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
jlong PSParallelCompact::millis_since_last_gc() {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22221
diff changeset
  3037
  // We need a monotonically non-decreasing time in ms but
11251
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11178
diff changeset
  3038
  // os::javaTimeMillis() does not guarantee monotonicity.
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11178
diff changeset
  3039
  jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11178
diff changeset
  3040
  jlong ret_val = now - _time_of_last_gc;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3041
  // XXX See note in genCollectedHeap::millis_since_last_gc().
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3042
  if (ret_val < 0) {
29798
451c73fdf690 8076071: parallelScavenge: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents: 29792
diff changeset
  3043
    NOT_PRODUCT(warning("time warp: " JLONG_FORMAT, ret_val);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
  return ret_val;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3049
void PSParallelCompact::reset_millis_since_last_gc() {
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22221
diff changeset
  3050
  // We need a monotonically non-decreasing time in ms but
11251
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11178
diff changeset
  3051
  // os::javaTimeMillis() does not guarantee monotonicity.
e29da6b5622b 7117303: VM uses non-monotonic time source and complains that it is non-monotonic
johnc
parents: 11178
diff changeset
  3052
  _time_of_last_gc = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
ParMarkBitMap::IterationStatus MoveAndUpdateClosure::copy_until_full()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3057
  if (source() != destination()) {
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  3058
    DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
    Copy::aligned_conjoint_words(source(), destination(), words_remaining());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3061
  update_state(words_remaining());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
  assert(is_full(), "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
  return ParMarkBitMap::full;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
void MoveAndUpdateClosure::copy_partial_obj()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
  size_t words = words_remaining();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
  HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
  HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
  if (end_addr < range_end) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
    words = bitmap()->obj_size(source(), end_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3076
  // This test is necessary; if omitted, the pointer updates to a partial object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3077
  // that crosses the dense prefix boundary could be overwritten.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
  if (source() != destination()) {
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  3079
    DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3080
    Copy::aligned_conjoint_words(source(), destination(), words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3082
  update_state(words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
30150
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3085
void InstanceKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3086
  oop_oop_iterate_oop_maps<true>(obj, PSParallelCompact::adjust_pointer_closure());
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3087
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3088
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3089
void InstanceMirrorKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3090
  InstanceKlass::oop_pc_update_pointers(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3091
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3092
  oop_oop_iterate_statics<true>(obj, PSParallelCompact::adjust_pointer_closure());
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3093
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3094
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3095
void InstanceClassLoaderKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3096
  InstanceKlass::oop_pc_update_pointers(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3097
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3098
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3099
#ifdef ASSERT
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3100
template <class T> static void trace_reference_gc(const char *s, oop obj,
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3101
                                                  T* referent_addr,
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3102
                                                  T* next_addr,
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3103
                                                  T* discovered_addr) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3104
  if(TraceReferenceGC && PrintGCDetails) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3105
    gclog_or_tty->print_cr("%s obj " PTR_FORMAT, s, p2i(obj));
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3106
    gclog_or_tty->print_cr("     referent_addr/* " PTR_FORMAT " / "
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3107
                           PTR_FORMAT, p2i(referent_addr),
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3108
                           referent_addr ? p2i(oopDesc::load_decode_heap_oop(referent_addr)) : NULL);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3109
    gclog_or_tty->print_cr("     next_addr/* " PTR_FORMAT " / "
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3110
                           PTR_FORMAT, p2i(next_addr),
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3111
                           next_addr ? p2i(oopDesc::load_decode_heap_oop(next_addr)) : NULL);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3112
    gclog_or_tty->print_cr("     discovered_addr/* " PTR_FORMAT " / "
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3113
                           PTR_FORMAT, p2i(discovered_addr),
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3114
                           discovered_addr ? p2i(oopDesc::load_decode_heap_oop(discovered_addr)) : NULL);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3115
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3116
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3117
#endif
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3118
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3119
template <class T>
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3120
static void oop_pc_update_pointers_specialized(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3121
  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: 29798
diff changeset
  3122
  PSParallelCompact::adjust_pointer(referent_addr);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3123
  T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3124
  PSParallelCompact::adjust_pointer(next_addr);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3125
  T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3126
  PSParallelCompact::adjust_pointer(discovered_addr);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3127
  debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3128
                                referent_addr, next_addr, discovered_addr);)
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3129
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3130
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3131
void InstanceRefKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3132
  InstanceKlass::oop_pc_update_pointers(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3133
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3134
  if (UseCompressedOops) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3135
    oop_pc_update_pointers_specialized<narrowOop>(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3136
  } else {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3137
    oop_pc_update_pointers_specialized<oop>(obj);
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3138
  }
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3139
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3140
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3141
void ObjArrayKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3142
  assert(obj->is_objArray(), "obj must be obj array");
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3143
  oop_oop_iterate_elements<true>(objArrayOop(obj), PSParallelCompact::adjust_pointer_closure());
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3144
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3145
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3146
void TypeArrayKlass::oop_pc_update_pointers(oop obj) {
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3147
  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: 29798
diff changeset
  3148
}
d9c940aa42ef 8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents: 29798
diff changeset
  3149
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
ParMarkBitMapClosure::IterationStatus
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
  assert(destination() != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
  assert(bitmap()->obj_size(addr) == words, "bad size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3155
  _source = addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3156
  assert(PSParallelCompact::summary_data().calc_new_pointer(source()) ==
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
         destination(), "wrong destination");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
  if (words > words_remaining()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
    return ParMarkBitMap::would_overflow;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
  // The start_array must be updated even if the object is not moving.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
  if (_start_array != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
    _start_array->allocate_block(destination());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3166
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
  if (destination() != source()) {
1682
94ad5692b3a7 6784849: par compact - can fail when to_space is non-empty
jcoomes
parents: 1670
diff changeset
  3169
    DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
    Copy::aligned_conjoint_words(source(), destination(), words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
  oop moved_oop = (oop) destination();
29792
8c6fa07f0869 8075957: Reduce calls to the GC specific object visitors in oopDesc
stefank
parents: 29325
diff changeset
  3174
  compaction_manager()->update_contents(moved_oop);
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32623
diff changeset
  3175
  assert(moved_oop->is_oop_or_null(), "Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
  update_state(words);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
  assert(destination() == (HeapWord*)moved_oop + moved_oop->size(), "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
  return is_full() ? ParMarkBitMap::full : ParMarkBitMap::incomplete;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
UpdateOnlyClosure::UpdateOnlyClosure(ParMarkBitMap* mbm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
                                     ParCompactionManager* cm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
                                     PSParallelCompact::SpaceId space_id) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
  ParMarkBitMapClosure(mbm, cm),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
  _space_id(space_id),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
  _start_array(PSParallelCompact::start_array(space_id))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3191
// Updates the references in the object to their new values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
ParMarkBitMapClosure::IterationStatus
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
UpdateOnlyClosure::do_addr(HeapWord* addr, size_t words) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3194
  do_addr(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3195
  return ParMarkBitMap::incomplete;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
}