hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp
author brutisso
Tue, 02 Dec 2014 09:51:16 +0100
changeset 27903 14c6e2f23fa0
parent 27899 17754211a7ab
child 28031 10aec24d2b61
child 28163 322d55d167be
permissions -rw-r--r--
8065992: Change CMSCollector::_young_gen to be a ParNewGeneration* Reviewed-by: mgerdin, kbarrett
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15605
bf7de87bbe3a 8006432: Ratio flags should be unsigned
jwilhelm
parents: 13728
diff changeset
     2
 * Copyright (c) 2001, 2013, 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: 5343
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5343
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: 5343
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: 6985
diff changeset
    25
#ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    26
#define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    27
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
    28
#include "gc_implementation/shared/gcHeapSummary.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    29
#include "gc_implementation/shared/gSpaceCounters.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    30
#include "gc_implementation/shared/gcStats.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
    31
#include "gc_implementation/shared/gcWhen.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    32
#include "gc_implementation/shared/generationCounters.hpp"
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 12379
diff changeset
    33
#include "memory/freeBlockDictionary.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    34
#include "memory/generation.hpp"
25492
d27050bdfb04 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 25491
diff changeset
    35
#include "memory/iterator.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    36
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    37
#include "runtime/virtualspace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    38
#include "services/memoryService.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    39
#include "utilities/bitMap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    40
#include "utilities/stack.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    41
#include "utilities/taskqueue.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    42
#include "utilities/yieldingWorkgroup.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
    43
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// ConcurrentMarkSweepGeneration is in support of a concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// mark-sweep old generation in the Detlefs-Printezis--Boehm-Demers-Schenker
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// style. We assume, for now, that this generation is always the
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    47
// seniormost generation and for simplicity
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// in the first implementation, that this generation is a single compactible
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// space. Neither of these restrictions appears essential, and will be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// relaxed in the future when more time is available to implement the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// greater generality (and there's a need for it).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// Concurrent mode failures are currently handled by
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// means of a sliding mark-compact.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
25485
9c3d427eed01 8034246: remove CMS and ParNew adaptive size policy code
jcoomes
parents: 25356
diff changeset
    56
class AdaptiveSizePolicy;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
class CMSConcMarkingTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
class CMSGCAdaptivePolicyCounters;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
    59
class CMSTracer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
    60
class ConcurrentGCTimer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
class ConcurrentMarkSweepGeneration;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
class ConcurrentMarkSweepPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
class ConcurrentMarkSweepThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
class CompactibleFreeListSpace;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
class FreeChunk;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
class PromotionInfo;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
class ScanMarkedObjectsAgainCarefullyClosure;
16681
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
    68
class TenuredGeneration;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
    69
class SerialOldTracer;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
// A generic CMS bit map. It's the basis for both the CMS marking bit map
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
// as well as for the mod union table (in each case only a subset of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
// methods are used). This is essentially a wrapper around the BitMap class,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// with one bit per (1<<_shifter) HeapWords. (i.e. for the marking bit map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// we have _shifter == 0. and for the mod union table we have
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
// shifter == CardTableModRefBS::card_shift - LogHeapWordSize.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
// XXX 64-bit issues in BitMap?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
class CMSBitMap VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  HeapWord* _bmStartWord;   // base address of range covered by map
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  size_t    _bmWordSize;    // map size (in #HeapWords covered)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  const int _shifter;       // shifts to convert HeapWord to bit position
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  VirtualSpace _virtual_space; // underlying the bit map
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  BitMap    _bm;            // the bit map itself
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  Mutex* const _lock;       // mutex protecting _bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  // constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  CMSBitMap(int shifter, int mutex_rank, const char* mutex_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  // allocates the actual storage for the map
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  bool allocate(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // field getter
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  Mutex* lock() const { return _lock; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  // locking verifier convenience function
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  void assert_locked() const PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  // inquiries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  HeapWord* startWord()   const { return _bmStartWord; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  size_t    sizeInWords() const { return _bmWordSize;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  size_t    sizeInBits()  const { return _bm.size();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  // the following is one past the last word in space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  HeapWord* endWord()     const { return _bmStartWord + _bmWordSize; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // reading marks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  bool isMarked(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  bool par_isMarked(HeapWord* addr) const; // do not lock checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  bool isUnmarked(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  bool isAllClear() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  // writing marks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  void mark(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  // For marking by parallel GC threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  // returns true if we did, false if another thread did
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  bool par_mark(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  void mark_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  void par_mark_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  void mark_large_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  void par_mark_large_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  void par_clear(HeapWord* addr); // For unmarking by parallel GC threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  void clear_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  void par_clear_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  void clear_large_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  void par_clear_large_range(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  void clear_all();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  void clear_all_incrementally();  // Not yet implemented!!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  NOT_PRODUCT(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
    // checks the memory region for validity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    void region_invariant(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  void iterate(BitMapClosure* cl) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    _bm.iterate(cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  void iterate(BitMapClosure* cl, HeapWord* left, HeapWord* right);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  void dirty_range_iterate_clear(MemRegionClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  void dirty_range_iterate_clear(MemRegion mr, MemRegionClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // auxiliary support for iteration
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  HeapWord* getNextMarkedWordAddress(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  HeapWord* getNextMarkedWordAddress(HeapWord* start_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
                                            HeapWord* end_addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  HeapWord* getNextUnmarkedWordAddress(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  HeapWord* getNextUnmarkedWordAddress(HeapWord* start_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
                                              HeapWord* end_addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  MemRegion getAndClearMarkedRegion(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  MemRegion getAndClearMarkedRegion(HeapWord* start_addr,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
                                           HeapWord* end_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  // conversion utilities
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  HeapWord* offsetToHeapWord(size_t offset) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  size_t    heapWordToOffset(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  size_t    heapWordDiffToOffsetDiff(size_t diff) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16681
diff changeset
   160
  void print_on_error(outputStream* st, const char* prefix) const;
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16681
diff changeset
   161
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // is this address range covered by the bit-map?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  NOT_PRODUCT(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
    bool covers(MemRegion mr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    bool covers(HeapWord* start, size_t size = 0) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  void verifyNoOneBitsInRange(HeapWord* left, HeapWord* right) PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
// Represents a marking stack used by the CMS collector.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
// Ideally this should be GrowableArray<> just like MSC's marking stack(s).
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   173
class CMSMarkStack: public CHeapObj<mtGC>  {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  //
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   175
  friend class CMSCollector;   // To get at expansion stats further below.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   178
  VirtualSpace _virtual_space;  // Space for the stack
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   179
  oop*   _base;      // Bottom of stack
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   180
  size_t _index;     // One more than last occupied index
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   181
  size_t _capacity;  // Max #elements
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   182
  Mutex  _par_lock;  // An advisory lock used in case of parallel access
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   183
  NOT_PRODUCT(size_t _max_depth;)  // Max depth plumbed during run
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
 protected:
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   186
  size_t _hit_limit;      // We hit max stack size limit
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   187
  size_t _failed_double;  // We failed expansion before hitting limit
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  CMSMarkStack():
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    _par_lock(Mutex::event, "CMSMarkStack._par_lock", true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
    _hit_limit(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    _failed_double(0) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  bool allocate(size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  size_t capacity() const { return _capacity; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  oop pop() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    if (!isEmpty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
      return _base[--_index] ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  bool push(oop ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    if (isFull()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      _base[_index++] = ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      NOT_PRODUCT(_max_depth = MAX2(_max_depth, _index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  bool isEmpty() const { return _index == 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  bool isFull()  const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    assert(_index <= _capacity, "buffer overflow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    return _index == _capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  size_t length() { return _index; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  // "Parallel versions" of some of the above
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  oop par_pop() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    // lock and pop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    return pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  bool par_push(oop ptr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    // lock and push
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    MutexLockerEx x(&_par_lock, Mutex::_no_safepoint_check_flag);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    return push(ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  // Forcibly reset the stack, losing all of its contents.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  void reset() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    _index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   242
  // Expand the stack, typically in response to an overflow condition.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  void expand();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  // Compute the least valued stack element.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  oop least_value(HeapWord* low) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
     oop least = (oop)low;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
     for (size_t i = 0; i < _index; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
       least = MIN2(least, _base[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
     return least;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   254
  // Exposed here to allow stack expansion in || case.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  Mutex* par_lock() { return &_par_lock; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
class CardTableRS;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
class CMSParGCThreadState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
class ModUnionClosure: public MemRegionClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  CMSBitMap* _t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  ModUnionClosure(CMSBitMap* t): _t(t) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  void do_MemRegion(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
class ModUnionClosurePar: public ModUnionClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  ModUnionClosurePar(CMSBitMap* t): ModUnionClosure(t) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  void do_MemRegion(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
// Survivor Chunk Array in support of parallelization of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
// Survivor Space rescan.
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   277
class ChunkArray: public CHeapObj<mtGC> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  size_t _index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  size_t _capacity;
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   280
  size_t _overflows;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  HeapWord** _array;   // storage for array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
 public:
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   284
  ChunkArray() : _index(0), _capacity(0), _overflows(0), _array(NULL) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  ChunkArray(HeapWord** a, size_t c):
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   286
    _index(0), _capacity(c), _overflows(0), _array(a) {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  HeapWord** array() { return _array; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  void set_array(HeapWord** a) { _array = a; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  size_t capacity() { return _capacity; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  void set_capacity(size_t c) { _capacity = c; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  size_t end() {
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   295
    assert(_index <= capacity(),
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   296
           err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT "): out of bounds",
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   297
                   _index, _capacity));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    return _index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }  // exclusive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  HeapWord* nth(size_t n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    assert(n < end(), "Out of bounds access");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    return _array[n];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  void reset() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    _index = 0;
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   308
    if (_overflows > 0 && PrintCMSStatistics > 1) {
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   309
      warning("CMS: ChunkArray[" SIZE_FORMAT "] overflowed " SIZE_FORMAT " times",
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   310
              _capacity, _overflows);
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   311
    }
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   312
    _overflows = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  void record_sample(HeapWord* p, size_t sz) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    // For now we do not do anything with the size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    if (_index < _capacity) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
      _array[_index++] = p;
6423
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   319
    } else {
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   320
      ++_overflows;
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   321
      assert(_index == _capacity,
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   322
             err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   323
                     "): out of bounds at overflow#" SIZE_FORMAT,
1ef0582c27c2 6910183: CMS: assert(_index < capacity(),"_index out of bounds")
ysr
parents: 6258
diff changeset
   324
                     _index, _capacity, _overflows));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
// Timing, allocation and promotion statistics for gc scheduling and incremental
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
// mode pacing.  Most statistics are exponential averages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
class CMSStats VALUE_OBJ_CLASS_SPEC {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  ConcurrentMarkSweepGeneration* const _cms_gen;   // The cms (old) gen.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // The following are exponential averages with factor alpha:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  //   avg = (100 - alpha) * avg + alpha * cur_sample
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  //   The durations measure:  end_time[n] - start_time[n]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  //   The periods measure:    start_time[n] - start_time[n-1]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // The cms period and duration include only concurrent collections; time spent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // in foreground cms collections due to System.gc() or because of a failure to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // keep up are not included.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // There are 3 alphas to "bootstrap" the statistics.  The _saved_alpha is the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // real value, but is used only after the first period.  A value of 100 is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  // used for the first sample so it gets the entire weight.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  unsigned int _saved_alpha; // 0-100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  unsigned int _gc0_alpha;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  unsigned int _cms_alpha;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  double _gc0_duration;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  double _gc0_period;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  size_t _gc0_promoted;         // bytes promoted per gc0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  double _cms_duration;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  double _cms_duration_pre_sweep; // time from initiation to start of sweep
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  double _cms_period;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  size_t _cms_allocated;        // bytes of direct allocation per gc0 period
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // Timers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  elapsedTimer _cms_timer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  TimeStamp    _gc0_begin_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  TimeStamp    _cms_begin_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  TimeStamp    _cms_end_time;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // Snapshots of the amount used in the CMS generation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  size_t _cms_used_at_gc0_begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  size_t _cms_used_at_gc0_end;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  size_t _cms_used_at_cms_begin;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  // Used to prevent the duty cycle from being reduced in the middle of a cms
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  // cycle.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  bool _allow_duty_cycle_reduction;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    _GC0_VALID = 0x1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    _CMS_VALID = 0x2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    _ALL_VALID = _GC0_VALID | _CMS_VALID
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  unsigned int _valid_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
 protected:
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   386
  // In support of adjusting of cms trigger ratios based on history
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   387
  // of concurrent mode failure.
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   388
  double cms_free_adjustment_factor(size_t free) const;
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   389
  void   adjust_cms_free_adjustment_factor(bool fail, size_t free);
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   390
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  CMSStats(ConcurrentMarkSweepGeneration* cms_gen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
           unsigned int alpha = CMSExpAvgFactor);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // Whether or not the statistics contain valid data; higher level statistics
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // cannot be called until this returns true (they require at least one young
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  // gen and one cms cycle to have completed).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  bool valid() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  // Record statistics.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  void record_gc0_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  void record_gc0_end(size_t cms_gen_bytes_used);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  void record_cms_begin();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  void record_cms_end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  // Allow management of the cms timer, which must be stopped/started around
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  // yield points.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  elapsedTimer& cms_timer()     { return _cms_timer; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  void start_cms_timer()        { _cms_timer.start(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  void stop_cms_timer()         { _cms_timer.stop(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  // Basic statistics; units are seconds or bytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  double gc0_period() const     { return _gc0_period; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  double gc0_duration() const   { return _gc0_duration; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  size_t gc0_promoted() const   { return _gc0_promoted; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  double cms_period() const          { return _cms_period; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  double cms_duration() const        { return _cms_duration; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  size_t cms_allocated() const       { return _cms_allocated; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  size_t cms_used_at_gc0_end() const { return _cms_used_at_gc0_end;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  // Seconds since the last background cms cycle began or ended.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  double cms_time_since_begin() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  double cms_time_since_end() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  // Higher level statistics--caller must check that valid() returns true before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  // calling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  // Returns bytes promoted per second of wall clock time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  double promotion_rate() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  // Returns bytes directly allocated per second of wall clock time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  double cms_allocation_rate() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  // Rate at which space in the cms generation is being consumed (sum of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // above two).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  double cms_consumption_rate() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  // Returns an estimate of the number of seconds until the cms generation will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  // fill up, assuming no collection work is done.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  double time_until_cms_gen_full() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // Returns an estimate of the number of seconds remaining until
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  // the cms generation collection should start.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  double time_until_cms_start() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // End of higher level statistics.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  void print_on(outputStream* st) const PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  void print() const { print_on(gclog_or_tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
// A closure related to weak references processing which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
// we embed in the CMSCollector, since we need to pass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
// it to the reference processor for secondary filtering
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
// of references based on reachability of referent;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
// see role of _is_alive_non_header closure in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
// ReferenceProcessor class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
// For objects in the CMS generation, this closure checks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
// if the object is "live" (reachable). Used in weak
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
// reference processing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
class CMSIsAliveClosure: public BoolObjectClosure {
390
2e094c1be4af 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents: 360
diff changeset
   464
  const MemRegion  _span;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  const CMSBitMap* _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  friend class CMSCollector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  CMSIsAliveClosure(MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
                    CMSBitMap* bit_map):
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    _span(span),
390
2e094c1be4af 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents: 360
diff changeset
   472
    _bit_map(bit_map) {
2e094c1be4af 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents: 360
diff changeset
   473
    assert(!span.is_empty(), "Empty span could spell trouble");
2e094c1be4af 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents: 360
diff changeset
   474
  }
2e094c1be4af 6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents: 360
diff changeset
   475
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  bool do_object_b(oop obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
// Implements AbstractRefProcTaskExecutor for CMS.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
class CMSRefProcTaskExecutor: public AbstractRefProcTaskExecutor {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  CMSRefProcTaskExecutor(CMSCollector& collector)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    : _collector(collector)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  // Executes a task using worker threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  virtual void execute(ProcessTask& task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  virtual void execute(EnqueueTask& task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  CMSCollector& _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   496
class CMSCollector: public CHeapObj<mtGC> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  friend class ConcurrentMarkSweepThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  friend class ConcurrentMarkSweepGeneration;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  friend class CompactibleFreeListSpace;
18996
05c86e558c94 6412968: CMS Long initial mark pauses
jmasa
parents: 18994
diff changeset
   501
  friend class CMSParMarkTask;
05c86e558c94 6412968: CMS Long initial mark pauses
jmasa
parents: 18994
diff changeset
   502
  friend class CMSParInitialMarkTask;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  friend class CMSParRemarkTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  friend class CMSConcMarkingTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  friend class CMSRefProcTaskProxy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  friend class CMSRefProcTaskExecutor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  friend class ScanMarkedObjectsAgainCarefullyClosure;  // for sampling eden
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  friend class SurvivorSpacePrecleanClosure;            // --- ditto -------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  friend class PushOrMarkClosure;             // to access _restart_addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  friend class Par_PushOrMarkClosure;             // to access _restart_addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  friend class MarkFromRootsClosure;          //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
                                              // ... and for clearing cards
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  friend class Par_MarkFromRootsClosure;      //  to access _restart_addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
                                              // ... and for clearing cards
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  friend class Par_ConcMarkingClosure;        //  to access _restart_addr etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  friend class MarkFromRootsVerifyClosure;    // to access _restart_addr
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  friend class PushAndMarkVerifyClosure;      //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  friend class MarkRefsIntoAndScanClosure;    // to access _overflow_list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  friend class PushAndMarkClosure;            //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  friend class Par_PushAndMarkClosure;        //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  friend class CMSKeepAliveClosure;           //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  friend class CMSDrainMarkingStackClosure;   //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  friend class CMSInnerParMarkAndPushClosure; //  -- ditto --
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  NOT_PRODUCT(friend class ScanMarkedObjectsAgainClosure;) //  assertion on _overflow_list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  friend class ReleaseForegroundGC;  // to access _foregroundGCShouldWait
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  friend class VM_CMS_Operation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  friend class VM_CMS_Initial_Mark;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  friend class VM_CMS_Final_Remark;
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
   529
  friend class TraceCMSMemoryManagerStats;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  jlong _time_of_last_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  void update_time_of_last_gc(jlong now) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    _time_of_last_gc = now;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  OopTaskQueueSet* _task_queues;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  // Overflow list of grey objects, threaded through mark-word
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // Manipulated with CAS in the parallel/multi-threaded case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  oop _overflow_list;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  // The following array-pair keeps track of mark words
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   543
  // displaced for accommodating overflow list above.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  // This code will likely be revisited under RFE#4922830.
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   545
  Stack<oop, mtGC>     _preserved_oop_stack;
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12630
diff changeset
   546
  Stack<markOop, mtGC> _preserved_mark_stack;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  int*             _hash_seed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // In support of multi-threaded concurrent phases
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  YieldingFlexibleWorkGang* _conc_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // Performance Counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  CollectorCounters* _gc_counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  // Initialization Errors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  bool _completed_initialization;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // In support of ExplicitGCInvokesConcurrent
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   560
  static bool _full_gc_requested;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   561
  static GCCause::Cause _full_gc_cause;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   562
  unsigned int _collection_count_start;
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   563
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  // Should we unload classes this concurrent cycle?
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   565
  bool _should_unload_classes;
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   566
  unsigned int  _concurrent_cycles_since_last_unload;
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   567
  unsigned int concurrent_cycles_since_last_unload() const {
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   568
    return _concurrent_cycles_since_last_unload;
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   569
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  // Did we (allow) unload classes in the previous concurrent cycle?
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   571
  bool unloaded_classes_last_cycle() const {
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   572
    return concurrent_cycles_since_last_unload() == 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  }
2885
7dd49b9daa4a 6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents: 2105
diff changeset
   574
  // Root scanning options for perm gen
7dd49b9daa4a 6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents: 2105
diff changeset
   575
  int _roots_scanning_options;
7dd49b9daa4a 6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents: 2105
diff changeset
   576
  int roots_scanning_options() const      { return _roots_scanning_options; }
7dd49b9daa4a 6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents: 2105
diff changeset
   577
  void add_root_scanning_option(int o)    { _roots_scanning_options |= o;   }
7dd49b9daa4a 6848641: CMSCollector::_roots_scanning_options should be initialized
ysr
parents: 2105
diff changeset
   578
  void remove_root_scanning_option(int o) { _roots_scanning_options &= ~o;  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  // Verification support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  CMSBitMap     _verification_mark_bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  void verify_after_remark_work_1();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
  void verify_after_remark_work_2();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   585
  // True if any verification flag is on.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  bool _verifying;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  bool verifying() const { return _verifying; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  void set_verifying(bool v) { _verifying = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  // Collector policy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  ConcurrentMarkSweepPolicy* _collector_policy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  ConcurrentMarkSweepPolicy* collector_policy() { return _collector_policy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
17325
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
   594
  void set_did_compact(bool v);
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
   595
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  // XXX Move these to CMSStats ??? FIX ME !!!
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   597
  elapsedTimer _inter_sweep_timer;   // Time between sweeps
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   598
  elapsedTimer _intra_sweep_timer;   // Time _in_ sweeps
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   599
  // Padded decaying average estimates of the above
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   600
  AdaptivePaddedAverage _inter_sweep_estimate;
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   601
  AdaptivePaddedAverage _intra_sweep_estimate;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   603
  CMSTracer* _gc_tracer_cm;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   604
  ConcurrentGCTimer* _gc_timer_cm;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   605
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   606
  bool _cms_start_registered;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   607
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   608
  GCHeapSummary _last_heap_summary;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   609
  MetaspaceSummary _last_metaspace_summary;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   610
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   611
  void register_gc_start(GCCause::Cause cause);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   612
  void register_gc_end();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   613
  void save_heap_summary();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   614
  void report_heap_summary(GCWhen::Type when);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   615
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
 protected:
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   617
  ConcurrentMarkSweepGeneration* _cmsGen;  // Old gen (CMS)
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   618
  MemRegion                      _span;    // Span covering above two
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   619
  CardTableRS*                   _ct;      // Card table
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  // CMS marking support structures
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  CMSBitMap     _markBitMap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  CMSBitMap     _modUnionTable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  CMSMarkStack  _markStack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   626
  HeapWord*     _restart_addr; // In support of marking stack overflow
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  void          lower_restart_addr(HeapWord* low);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  // Counters in support of marking stack / work queue overflow handling:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  // a non-zero value indicates certain types of overflow events during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  // the current CMS cycle and could lead to stack resizing efforts at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  // an opportune future time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  size_t        _ser_pmc_preclean_ovflw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  size_t        _ser_pmc_remark_ovflw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  size_t        _par_pmc_remark_ovflw;
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
   636
  size_t        _ser_kac_preclean_ovflw;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  size_t        _ser_kac_ovflw;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  size_t        _par_kac_ovflw;
1910
386106352d02 6786503: Overflow list performance can be improved
ysr
parents: 1893
diff changeset
   639
  NOT_PRODUCT(ssize_t _num_par_pushes;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   641
  // ("Weak") Reference processing support.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  ReferenceProcessor*            _ref_processor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  CMSIsAliveClosure              _is_alive_closure;
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   644
  // Keep this textually after _markBitMap and _span; c'tor dependency.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   646
  ConcurrentMarkSweepThread*     _cmsThread;   // The thread doing the work
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  ModUnionClosure    _modUnionClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  ModUnionClosurePar _modUnionClosurePar;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  // CMS abstract state machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  // initial_state: Idling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
  // next_state(Idling)            = {Marking}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  // next_state(Marking)           = {Precleaning, Sweeping}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // next_state(Precleaning)       = {AbortablePreclean, FinalMarking}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  // next_state(AbortablePreclean) = {FinalMarking}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  // next_state(FinalMarking)      = {Sweeping}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  // next_state(Sweeping)          = {Resizing}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  // next_state(Resizing)          = {Resetting}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // next_state(Resetting)         = {Idling}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  // The numeric values below are chosen so that:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // . _collectorState <= Idling ==  post-sweep && pre-mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  // . _collectorState in (Idling, Sweeping) == {initial,final}marking ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  //                                            precleaning || abortablePrecleanb
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   664
 public:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  enum CollectorState {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
    Resizing            = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    Resetting           = 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
    Idling              = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    InitialMarking      = 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    Marking             = 4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    Precleaning         = 5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    AbortablePreclean   = 6,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    FinalMarking        = 7,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    Sweeping            = 8
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  };
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   676
 protected:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  static CollectorState _collectorState;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  // State related to prologue/epilogue invocation for my generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  bool _between_prologue_and_epilogue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   682
  // Signaling/State related to coordination between fore- and background GC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  // Note: When the baton has been passed from background GC to foreground GC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  // _foregroundGCIsActive is true and _foregroundGCShouldWait is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  static bool _foregroundGCIsActive;    // true iff foreground collector is active or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
                                 // wants to go active
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  static bool _foregroundGCShouldWait;  // true iff background GC is active and has not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
                                 // yet passed the baton to the foreground GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  // Support for CMSScheduleRemark (abortable preclean)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
  bool _abort_preclean;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  bool _start_sampling;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  int    _numYields;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  size_t _numDirtyCards;
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   696
  size_t _sweep_count;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   698
  // Occupancy used for bootstrapping stats
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  double _bootstrap_occupancy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   701
  // Timer
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  elapsedTimer _timer;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  // Timing, allocation and promotion statistics, used for scheduling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  CMSStats      _stats;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  enum CMS_op_type {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    CMS_op_checkpointRootsInitial,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    CMS_op_checkpointRootsFinal
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
12630
ddf6ee008138 7166894: Add gc cause to GC logging for all collectors
brutisso
parents: 12507
diff changeset
   712
  void do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  bool stop_world_and_do(CMS_op_type op);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  OopTaskQueueSet* task_queues() { return _task_queues; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  int*             hash_seed(int i) { return &_hash_seed[i]; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  YieldingFlexibleWorkGang* conc_workers() { return _conc_workers; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  // Support for parallelizing Eden rescan in CMS remark phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  void sample_eden(); // ... sample Eden space top
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  // Support for parallelizing young gen rescan in CMS remark phase
27903
14c6e2f23fa0 8065992: Change CMSCollector::_young_gen to be a ParNewGeneration*
brutisso
parents: 27899
diff changeset
   724
  ParNewGeneration* _young_gen;  // the younger gen
14c6e2f23fa0 8065992: Change CMSCollector::_young_gen to be a ParNewGeneration*
brutisso
parents: 27899
diff changeset
   725
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  HeapWord** _top_addr;    // ... Top of Eden
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  HeapWord** _end_addr;    // ... End of Eden
18994
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
   728
  Mutex*     _eden_chunk_lock;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  HeapWord** _eden_chunk_array; // ... Eden partitioning array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  size_t     _eden_chunk_index; // ... top (exclusive) of array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  size_t     _eden_chunk_capacity;  // ... max entries in array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  // Support for parallelizing survivor space rescan
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  HeapWord** _survivor_chunk_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  size_t     _survivor_chunk_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  size_t     _survivor_chunk_capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
  size_t*    _cursor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  ChunkArray* _survivor_plab_array;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  // Support for marking stack overflow handling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  bool take_from_overflow_list(size_t num, CMSMarkStack* to_stack);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6423
diff changeset
   742
  bool par_take_from_overflow_list(size_t num,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6423
diff changeset
   743
                                   OopTaskQueue* to_work_q,
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6423
diff changeset
   744
                                   int no_of_gc_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  void push_on_overflow_list(oop p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  void par_push_on_overflow_list(oop p);
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   747
  // The following is, obviously, not, in general, "MT-stable"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  bool overflow_list_is_empty() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  void preserve_mark_if_necessary(oop p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  void par_preserve_mark_if_necessary(oop p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  void preserve_mark_work(oop p, markOop m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  void restore_preserved_marks_if_any();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  NOT_PRODUCT(bool no_preserved_marks() const;)
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   755
  // In support of testing overflow code
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  NOT_PRODUCT(int _overflow_counter;)
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   757
  NOT_PRODUCT(bool simulate_overflow();)       // Sequential
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  NOT_PRODUCT(bool par_simulate_overflow();)   // MT version
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  // CMS work methods
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   761
  void checkpointRootsInitialWork(); // Initial checkpoint work
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   763
  // A return value of false indicates failure due to stack overflow
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   764
  bool markFromRootsWork();  // Concurrent marking work
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
 public:   // FIX ME!!! only for testing
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   767
  bool do_marking_st();      // Single-threaded marking
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   768
  bool do_marking_mt();      // Multi-threaded  marking
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   772
  // Concurrent precleaning work
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
                                  ScanMarkedObjectsAgainCarefullyClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
                             ScanMarkedObjectsAgainCarefullyClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  // Does precleaning work, returning a quantity indicative of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  // the amount of "useful work" done.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  size_t preclean_work(bool clean_refs, bool clean_survivors);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   780
  void preclean_klasses(MarkRefsIntoAndScanClosure* cl, Mutex* freelistLock);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  void abortable_preclean(); // Preclean while looking for possible abort
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  void initialize_sequential_subtasks_for_young_gen_rescan(int i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  // Helper function for above; merge-sorts the per-thread plab samples
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 6423
diff changeset
   784
  void merge_survivor_plab_arrays(ContiguousSpace* surv, int no_of_gc_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  // Resets (i.e. clears) the per-thread plab sample vectors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  void reset_survivor_plab_arrays();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   788
  // Final (second) checkpoint work
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   789
  void checkpointRootsFinalWork();
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   790
  // Work routine for parallel version of remark
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  void do_remark_parallel();
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   792
  // Work routine for non-parallel version of remark
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  void do_remark_non_parallel();
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   794
  // Reference processing work routine (during second checkpoint)
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   795
  void refProcessingWork();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   797
  // Concurrent sweeping work
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   798
  void sweepWork(ConcurrentMarkSweepGeneration* gen);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   800
  // (Concurrent) resetting of support data structures
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   801
  void reset(bool concurrent);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  // Clear _expansion_cause fields of constituent generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  void clear_expansion_cause();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   806
  // An auxiliary method used to record the ends of
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  // used regions of each generation to limit the extent of sweep
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  void save_sweep_limits();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  // A work method used by the foreground collector to do
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  // a mark-sweep-compact.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  void do_compaction_work(bool clear_all_soft_refs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   814
  // Work methods for reporting concurrent mode interruption or failure
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   815
  bool is_external_interruption();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   816
  void report_concurrent_mode_interruption();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   817
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   818
  // If the background GC is active, acquire control from the background
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  // GC and do the collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  void acquire_control_and_collect(bool   full, bool clear_all_soft_refs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  // For synchronizing passing of control from background to foreground
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  // GC.  waitForForegroundGC() is called by the background
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  // collector.  It if had to wait for a foreground collection,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  // it returns true and the background collection should assume
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  // that the collection was finished by the foreground
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  // collector.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  bool waitForForegroundGC();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  size_t block_size_using_printezis_bits(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  size_t block_size_if_printezis_bits(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  HeapWord* next_card_start_after_block(HeapWord* addr) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  void setup_cms_unloading_and_verification_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  CMSCollector(ConcurrentMarkSweepGeneration* cmsGen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
               CardTableRS*                   ct,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
               ConcurrentMarkSweepPolicy*     cp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  ConcurrentMarkSweepThread* cmsThread() { return _cmsThread; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  ReferenceProcessor* ref_processor() { return _ref_processor; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  void ref_processor_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  Mutex* bitMapLock()        const { return _markBitMap.lock();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  static CollectorState abstract_state() { return _collectorState;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  bool should_abort_preclean() const; // Whether preclean should be aborted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  size_t get_eden_used() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  size_t get_eden_capacity() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  ConcurrentMarkSweepGeneration* cmsGen() { return _cmsGen; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   853
  // Locking checks
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  NOT_PRODUCT(static bool have_cms_token();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  bool shouldConcurrentCollect();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  void collect(bool   full,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
               bool   clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
               size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
               bool   tlab);
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   862
  void collect_in_background(GCCause::Cause cause);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  // In support of ExplicitGCInvokesConcurrent
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17625
diff changeset
   865
  static void request_full_gc(unsigned int full_gc_count, GCCause::Cause cause);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  // Should we unload classes in a particular concurrent cycle?
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   867
  bool should_unload_classes() const {
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
   868
    return _should_unload_classes;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   870
  void update_should_unload_classes();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  void direct_allocated(HeapWord* start, size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  // Object is dead if not marked and current phase is sweeping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  bool is_dead_obj(oop obj) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  // After a promotion (of "start"), do any necessary marking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  // If "par", then it's being done by a parallel GC thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  // The last two args indicate if we need precise marking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
  // and if so the size of the object so it can be dirtied
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  // in its entirety.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  void promoted(bool par, HeapWord* start,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
                bool is_obj_array, size_t obj_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  void getFreelistLocks() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  void releaseFreelistLocks() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  bool haveFreelistLocks() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
16681
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
   889
  // Adjust size of underlying generation
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
   890
  void compute_new_size();
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
   891
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  // GC prologue and epilogue
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  void gc_prologue(bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
  void gc_epilogue(bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  jlong time_of_last_gc(jlong now) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    if (_collectorState <= Idling) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
      // gc not in progress
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
      return _time_of_last_gc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
      // collection in progress
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
      return now;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  // Support for parallel remark of survivor space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  void* get_data_recorder(int thr_num);
18994
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
   908
  void sample_eden_chunk();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  CMSBitMap* markBitMap()  { return &_markBitMap; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  void directAllocated(HeapWord* start, size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   913
  // Main CMS steps and related support
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   914
  void checkpointRootsInitial();
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   915
  bool markFromRoots();  // a return value of false indicates failure
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   916
                         // due to stack overflow
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  void preclean();
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   918
  void checkpointRootsFinal();
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
   919
  void sweep();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  // Check that the currently executing thread is the expected
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  // one (foreground collector or background collector).
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   923
  static void check_correct_thread_executing() PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  bool is_cms_reachable(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  // Performance Counter Support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  CollectorCounters* counters()    { return _gc_counters; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   930
  // Timer stuff
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
  void    startTimer() { assert(!_timer.is_active(), "Error"); _timer.start();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  void    stopTimer()  { assert( _timer.is_active(), "Error"); _timer.stop();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  void    resetTimer() { assert(!_timer.is_active(), "Error"); _timer.reset();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  double  timerValue() { assert(!_timer.is_active(), "Error"); return _timer.seconds(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  int  yields()          { return _numYields; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  void resetYields()     { _numYields = 0;    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  void incrementYields() { _numYields++;      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  void resetNumDirtyCards()               { _numDirtyCards = 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
  void incrementNumDirtyCards(size_t num) { _numDirtyCards += num; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  size_t  numDirtyCards()                 { return _numDirtyCards; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  static bool foregroundGCShouldWait() { return _foregroundGCShouldWait; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  static void set_foregroundGCShouldWait(bool v) { _foregroundGCShouldWait = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  static bool foregroundGCIsActive() { return _foregroundGCIsActive; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  static void set_foregroundGCIsActive(bool v) { _foregroundGCIsActive = v; }
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   947
  size_t sweep_count() const             { return _sweep_count; }
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
   948
  void   increment_sweep_count()         { _sweep_count++; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  // Timers/stats for gc scheduling and incremental mode pacing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  CMSStats& stats() { return _stats; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  // Adaptive size policy
25485
9c3d427eed01 8034246: remove CMS and ParNew adaptive size policy code
jcoomes
parents: 25356
diff changeset
   954
  AdaptiveSizePolicy* size_policy();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16681
diff changeset
   956
  static void print_on_error(outputStream* st);
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 16681
diff changeset
   957
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   958
  // Debugging
12379
2cf45b79ce3a 4988100: oop_verify_old_oop appears to be dead
brutisso
parents: 10240
diff changeset
   959
  void verify();
17112
e49af4ba7755 8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents: 16685
diff changeset
   960
  bool verify_after_remark(bool silent = VerifySilently);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  void verify_ok_to_terminate() const PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  void verify_work_stacks_empty() const PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  void verify_overflow_empty() const PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   965
  // Convenience methods in support of debugging
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
  static const size_t skip_header_HeapWords() PRODUCT_RETURN0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
  HeapWord* block_start(const void* p) const PRODUCT_RETURN0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
   969
  // Accessors
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  CMSMarkStack* verification_mark_stack() { return &_markStack; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  CMSBitMap*    verification_mark_bm()    { return &_verification_mark_bm; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
  // Initialization errors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
  bool completed_initialization() { return _completed_initialization; }
18994
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
   975
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
   976
  void print_eden_and_survivor_chunk_arrays();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
class CMSExpansionCause : public AllStatic  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  enum Cause {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
    _no_expansion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    _satisfy_free_ratio,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    _satisfy_promotion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    _satisfy_allocation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
    _allocate_par_lab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    _allocate_par_spooling_space,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
    _adaptive_size_policy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
  // Return a string describing the cause of the expansion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  static const char* to_string(CMSExpansionCause::Cause cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
class ConcurrentMarkSweepGeneration: public CardGeneration {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  friend class VMStructs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  friend class ConcurrentMarkSweepThread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
  friend class ConcurrentMarkSweep;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  friend class CMSCollector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  static CMSCollector*       _collector; // the collector that collects us
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  CompactibleFreeListSpace*  _cmsSpace;  // underlying space (only one for now)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  // Performance Counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  GenerationCounters*      _gen_counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  GSpaceCounters*          _space_counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  // Words directly allocated, used by CMSStats.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  size_t _direct_allocated_words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  // Non-product stat counters
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  NOT_PRODUCT(
6258
68f252c6e825 6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents: 6245
diff changeset
  1012
    size_t _numObjectsPromoted;
68f252c6e825 6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents: 6245
diff changeset
  1013
    size_t _numWordsPromoted;
68f252c6e825 6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents: 6245
diff changeset
  1014
    size_t _numObjectsAllocated;
68f252c6e825 6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
ysr
parents: 6245
diff changeset
  1015
    size_t _numWordsAllocated;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  // Used for sizing decisions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  bool _incremental_collection_failed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  bool incremental_collection_failed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
    return _incremental_collection_failed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  void set_incremental_collection_failed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
    _incremental_collection_failed = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  void clear_incremental_collection_failed() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
    _incremental_collection_failed = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1030
  // accessors
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1031
  void set_expansion_cause(CMSExpansionCause::Cause v) { _expansion_cause = v;}
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1032
  CMSExpansionCause::Cause expansion_cause() const { return _expansion_cause; }
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1033
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  // For parallel young-gen GC support.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  CMSParGCThreadState** _par_gc_thread_states;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  // Reason generation was expanded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  CMSExpansionCause::Cause _expansion_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  // In support of MinChunkSize being larger than min object size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  const double _dilatation_factor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
  1044
  // True if a compacting collection was done.
17325
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
  1045
  bool _did_compact;
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
  1046
  bool did_compact() { return _did_compact; }
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
  1047
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1048
  // Fraction of current occupancy at which to start a CMS collection which
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1049
  // will collect this generation (at least).
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1050
  double _initiating_occupancy;
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1051
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  // Shrink generation by specified size (returns false if unable to shrink)
16681
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1054
  void shrink_free_list_by(size_t bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  // Update statistics for GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  virtual void update_gc_stats(int level, bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  // Maximum available space in the generation (including uncommitted)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  // space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  size_t max_available() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1063
  // getter and initializer for _initiating_occupancy field.
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1064
  double initiating_occupancy() const { return _initiating_occupancy; }
15605
bf7de87bbe3a 8006432: Ratio flags should be unsigned
jwilhelm
parents: 13728
diff changeset
  1065
  void   init_initiating_occupancy(intx io, uintx tr);
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1066
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  ConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
                                int level, CardTableRS* ct,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
                                bool use_adaptive_freelists,
12507
6182ca66bc7b 7131629: Generalize the CMS free list code
jmasa
parents: 12379
diff changeset
  1071
                                FreeBlockDictionary<FreeChunk>::DictionaryChoice);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  // Accessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
  CMSCollector* collector() const { return _collector; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  static void set_collector(CMSCollector* collector) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
    assert(_collector == NULL, "already set");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
    _collector = collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  CompactibleFreeListSpace*  cmsSpace() const { return _cmsSpace;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
  Mutex* freelistLock() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  virtual Generation::Name kind() { return Generation::ConcurrentMarkSweep; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
17325
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
  1085
  void set_did_compact(bool v) { _did_compact = v; }
694922ea5785 8013184: CMS: Call reset_after_compaction() only if a compaction has been done
jmasa
parents: 17112
diff changeset
  1086
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  bool refs_discovery_is_atomic() const { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  bool refs_discovery_is_mt()     const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
    // Note: CMS does MT-discovery during the parallel-remark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
    // phases. Use ReferenceProcessorMTMutator to make refs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
    // discovery MT-safe during such phases or other parallel
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
    // discovery phases in the future. This may all go away
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    // if/when we decide that refs discovery is sufficiently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    // rare that the cost of the CAS's involved is in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
    // noise. That's a measurement that should be done, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
    // the code simplified if that turns out to be the case.
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7903
diff changeset
  1097
    return ConcGCThreads > 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  // Override
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  virtual void ref_processor_init();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
979
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1103
  // Grow generation by specified size (returns false if unable to grow)
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1104
  bool grow_by(size_t bytes);
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1105
  // Grow generation to reserved size.
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1106
  bool grow_to_reserved();
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1107
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
  void clear_expansion_cause() { _expansion_cause = CMSExpansionCause::_no_expansion; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  // Space enquiries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
  size_t capacity() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  size_t used() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  size_t free() const;
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1114
  double occupancy() const { return ((double)used())/((double)capacity()); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  size_t contiguous_available() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  size_t unsafe_max_alloc_nogc() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  // over-rides
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  MemRegion used_region() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
  MemRegion used_region_at_save_marks() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  // Does a "full" (forced) collection invoked on this generation collect
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
  // all younger generations as well? Note that the second conjunct is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  // hack to allow the collection of the younger gen first if the flag is
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 23535
diff changeset
  1125
  // set.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
  virtual bool full_collects_younger_generations() const {
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
  1127
    return !ScavengeBeforeFullGC;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  void space_iterate(SpaceClosure* blk, bool usedOnly = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  // Support for compaction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  CompactibleSpace* first_compaction_space() const;
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
  1134
  // Adjust quantities in the generation affected by
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  // the compaction.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  void reset_after_compaction();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  // Allocation support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  HeapWord* allocate(size_t size, bool tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  HeapWord* have_lock_and_allocate(size_t size, bool tlab);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1141
  oop       promote(oop obj, size_t obj_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
  HeapWord* par_allocate(size_t size, bool tlab) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
    return allocate(size, tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  // Used by CMSStats to track direct allocation.  The value is sampled and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  // reset after each young gen collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
  size_t direct_allocated_words() const { return _direct_allocated_words; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
  void reset_direct_allocated_words()   { _direct_allocated_words = 0; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  // Overrides for parallel promotion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  virtual oop par_promote(int thread_num,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
                          oop obj, markOop m, size_t word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  virtual void par_promote_alloc_done(int thread_num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  virtual void par_oop_since_save_marks_iterate_done(int thread_num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
6985
e9364ec299ac 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data
ysr
parents: 6762
diff changeset
  1158
  virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
4574
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
  1160
  // Inform this (non-young) generation that a promotion failure was
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
  1161
  // encountered during a collection of a younger generation that
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
  1162
  // promotes into this generation.
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
  1163
  virtual void promotion_failure_occurred();
b2d5b0975515 6631166: CMS: better heuristics when combatting fragmentation
ysr
parents: 3690
diff changeset
  1164
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  bool should_collect(bool full, size_t size, bool tlab);
341
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1166
  virtual bool should_concurrent_collect() const;
6578aad59716 6634032: CMS: Need CMSInitiatingPermOccupancyFraction for perm, divorcing from CMSInitiatingOccupancyFraction
ysr
parents: 1
diff changeset
  1167
  virtual bool is_too_full() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  void collect(bool   full,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
               bool   clear_all_soft_refs,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
               size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
               bool   tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  HeapWord* expand_and_allocate(size_t word_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
                                bool tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
                                bool parallel = false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  // GC prologue and epilogue
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  void gc_prologue(bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  void gc_prologue_work(bool full, bool registerClosure,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
                        ModUnionClosure* modUnionClosure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  void gc_epilogue(bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  void gc_epilogue_work(bool full);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  // Time since last GC of this generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  jlong time_of_last_gc(jlong now) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
    return collector()->time_of_last_gc(now);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  void update_time_of_last_gc(jlong now) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
    collector()-> update_time_of_last_gc(now);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  // Allocation failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  void expand(size_t bytes, size_t expand_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
    CMSExpansionCause::Cause cause);
979
c9479f1e0a94 6730514: assertion failure in mangling code when expanding by 0 bytes
jmasa
parents: 670
diff changeset
  1195
  virtual bool expand(size_t bytes, size_t expand_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
  void shrink(size_t bytes);
16681
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1197
  void shrink_by(size_t bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  HeapWord* expand_and_par_lab_allocate(CMSParGCThreadState* ps, size_t word_sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
  bool expand_and_ensure_spooling_space(PromotionInfo* promo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  // Iteration support and related enquiries
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  void save_marks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
  bool no_allocs_since_save_marks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  void younger_refs_iterate(OopsInGenClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  // Iteration support specific to CMS generations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
  void save_sweep_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  // More iteration support
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1210
  virtual void oop_iterate(ExtendedOopClosure* cl);
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1605
diff changeset
  1211
  virtual void safe_object_iterate(ObjectClosure* cl);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  virtual void object_iterate(ObjectClosure* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  // Need to declare the full complement of closures, whether we'll
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  // override them or not, or get message from the compiler:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  //   oop_since_save_marks_iterate_nv hides virtual function...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  #define CMS_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  ALL_SINCE_SAVE_MARKS_CLOSURES(CMS_SINCE_SAVE_MARKS_DECL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  // Smart allocation  XXX -- move to CFLSpace?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  void setNearLargestChunk();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  bool isNearLargestChunk(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
  1225
  // Get the chunk at the end of the space.  Delegates to
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  // the space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  FreeChunk* find_chunk_at_end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  void post_compact();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  // Debugging
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  void prepare_for_verify();
12379
2cf45b79ce3a 4988100: oop_verify_old_oop appears to be dead
brutisso
parents: 10240
diff changeset
  1233
  void verify();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  void print_statistics()               PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  // Performance Counters support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  virtual void update_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  virtual void update_counters(size_t used);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
  void initialize_performance_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  CollectorCounters* counters()  { return collector()->counters(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
  // Support for parallel remark of survivor space
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
  void* get_data_recorder(int thr_num) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
    //Delegate to collector
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
    return collector()->get_data_recorder(thr_num);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  }
18994
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
  1247
  void sample_eden_chunk() {
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
  1248
    //Delegate to collector
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
  1249
    return collector()->sample_eden_chunk();
d32a17b7502c 6990419: CMS Remaining work for 6572569: consistently skewed work distribution in (long) re-mark pauses
jmasa
parents: 18687
diff changeset
  1250
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  const char* name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  virtual const char* short_name() const { return "CMS"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  void        print() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  void printOccupancy(const char* s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
16681
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1258
  // Resize the generation after a compacting GC.  The
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1259
  // generation can be treated as a contiguous space
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1260
  // after the compaction.
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1261
  virtual void compute_new_size();
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1262
  // Resize the generation after a non-compacting
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1263
  // collection.
d64161ca3e3c 8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents: 15605
diff changeset
  1264
  void compute_new_size_free_list();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
// Closures of various sorts used by CMS to accomplish its work
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
// This closure is used to do concurrent marking from the roots
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
// following the first checkpoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
class MarkFromRootsClosure: public BitMapClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  CMSCollector*  _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
  MemRegion      _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  CMSBitMap*     _bitMap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  CMSBitMap*     _mut;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  CMSMarkStack*  _markStack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  bool           _yield;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
  int            _skipBits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
  HeapWord*      _finger;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  HeapWord*      _threshold;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  DEBUG_ONLY(bool _verifying;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
  MarkFromRootsClosure(CMSCollector* collector, MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
                       CMSBitMap* bitMap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
                       CMSMarkStack*  markStack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
                       bool should_yield, bool verifying = false);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 390
diff changeset
  1290
  bool do_bit(size_t offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
  void reset(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
  inline void do_yield_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
  void scanOopsInOop(HeapWord* ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
  void do_yield_work();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
// This closure is used to do concurrent multi-threaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
// marking from the roots following the first checkpoint.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
// XXX This should really be a subclass of The serial version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
// above, but i have not had the time to refactor things cleanly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
class Par_MarkFromRootsClosure: public BitMapClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
  CMSCollector*  _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
  MemRegion      _whole_span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  MemRegion      _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  CMSBitMap*     _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
  CMSBitMap*     _mut;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
  OopTaskQueue*  _work_queue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
  CMSMarkStack*  _overflow_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
  int            _skip_bits;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
  HeapWord*      _finger;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
  HeapWord*      _threshold;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  CMSConcMarkingTask* _task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
  Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
                       MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
                       CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
                       OopTaskQueue* work_queue,
27686
f91c482793e6 8064702: Remove the CMS foreground collector
brutisso
parents: 27625
diff changeset
  1320
                       CMSMarkStack*  overflow_stack);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 390
diff changeset
  1321
  bool do_bit(size_t offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
  inline void do_yield_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  void scan_oops_in_oop(HeapWord* ptr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
  void do_yield_work();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  bool get_work_from_overflow_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
// The following closures are used to do certain kinds of verification of
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
// CMS marking.
25356
4a4a482298a6 8046670: Make CMS metadata aware closures applicable for other collectors
stefank
parents: 24941
diff changeset
  1332
class PushAndMarkVerifyClosure: public MetadataAwareOopClosure {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  CMSCollector*    _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
  MemRegion        _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  CMSBitMap*       _verification_bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  CMSBitMap*       _cms_bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
  CMSMarkStack*    _mark_stack;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1338
 protected:
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1339
  void do_oop(oop p);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1340
  template <class T> inline void do_oop_work(T *p) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1341
    oop obj = oopDesc::load_decode_heap_oop(p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1342
    do_oop(obj);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1343
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
  PushAndMarkVerifyClosure(CMSCollector* cms_collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
                           MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
                           CMSBitMap* verification_bm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
                           CMSBitMap* cms_bm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
                           CMSMarkStack*  mark_stack);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  void do_oop(oop* p);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 341
diff changeset
  1351
  void do_oop(narrowOop* p);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1352
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  // Deal with a stack overflow condition
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
  void handle_stack_overflow(HeapWord* lost);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
class MarkFromRootsVerifyClosure: public BitMapClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  CMSCollector*  _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  MemRegion      _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  CMSBitMap*     _verification_bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  CMSBitMap*     _cms_bm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
  CMSMarkStack*  _mark_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  HeapWord*      _finger;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  PushAndMarkVerifyClosure _pam_verify_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  MarkFromRootsVerifyClosure(CMSCollector* collector, MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
                             CMSBitMap* verification_bm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
                             CMSBitMap* cms_bm,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
                             CMSMarkStack*  mark_stack);
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 390
diff changeset
  1370
  bool do_bit(size_t offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
  void reset(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
// This closure is used to check that a certain set of bits is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
// "empty" (i.e. the bit vector doesn't have any 1-bits).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
class FalseBitMapClosure: public BitMapClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
 public:
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 390
diff changeset
  1379
  bool do_bit(size_t offset) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    guarantee(false, "Should not have a 1 bit");
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 390
diff changeset
  1381
    return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
23535
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1385
// A version of ObjectClosure with "memory" (see _previous_address below)
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1386
class UpwardsObjectClosure: public BoolObjectClosure {
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1387
  HeapWord* _previous_address;
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1388
 public:
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1389
  UpwardsObjectClosure() : _previous_address(NULL) { }
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1390
  void set_previous(HeapWord* addr) { _previous_address = addr; }
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1391
  HeapWord* previous()              { return _previous_address; }
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1392
  // A return value of "true" can be used by the caller to decide
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1393
  // if this object's end should *NOT* be recorded in
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1394
  // _previous_address above.
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1395
  virtual bool do_object_bm(oop obj, MemRegion mr) = 0;
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1396
};
6306204d22a9 8038404: Move object_iterate_mem from Space to CMS since it is only ever used by CMS
mgerdin
parents: 23508
diff changeset
  1397
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
// This closure is used during the second checkpointing phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
// to rescan the marked objects on the dirty cards in the mod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
// union table and the card table proper. It's invoked via
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
// MarkFromDirtyCardsClosure below. It uses either
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
// [Par_]MarkRefsIntoAndScanClosure (Par_ in the parallel case)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
// declared in genOopClosures.hpp to accomplish some of its work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
// In the parallel case the bitMap is shared, so access to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
// it needs to be suitably synchronized for updates by embedded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
// closures that update it; however, this closure itself only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
// reads the bit_map and because it is idempotent, is immune to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
// reading stale values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
class ScanMarkedObjectsAgainClosure: public UpwardsObjectClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
  #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
    CMSCollector*          _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
    MemRegion              _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
    union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
      CMSMarkStack*        _mark_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
      OopTaskQueue*        _work_queue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
    };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  #endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
  bool                       _parallel;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
  CMSBitMap*                 _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
  union {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    MarkRefsIntoAndScanClosure*     _scan_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
    Par_MarkRefsIntoAndScanClosure* _par_scan_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
  ScanMarkedObjectsAgainClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
                                MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
                                ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
                                CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
                                CMSMarkStack*  mark_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
                                MarkRefsIntoAndScanClosure* cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
      _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
      _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
      _mark_stack(mark_stack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    #endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    _parallel(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
    _bit_map(bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    _scan_closure(cl) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
  ScanMarkedObjectsAgainClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
                                MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
                                ReferenceProcessor* rp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
                                CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
                                OopTaskQueue* work_queue,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
                                Par_MarkRefsIntoAndScanClosure* cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
    #ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
      _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
      _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
      _work_queue(work_queue),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    #endif // ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
    _parallel(true),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
    _bit_map(bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
    _par_scan_closure(cl) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
  bool do_object_b(oop obj) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    guarantee(false, "Call do_object_b(oop, MemRegion) form instead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
  bool do_object_bm(oop p, MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
// This closure is used during the second checkpointing phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
// to rescan the marked objects on the dirty cards in the mod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
// union table and the card table proper. It invokes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
// ScanMarkedObjectsAgainClosure above to accomplish much of its work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
// In the parallel case, the bit map is shared and requires
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
// synchronized access.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
class MarkFromDirtyCardsClosure: public MemRegionClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
  CompactibleFreeListSpace*      _space;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  ScanMarkedObjectsAgainClosure  _scan_cl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
  size_t                         _num_dirty_cards;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
  MarkFromDirtyCardsClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
                            MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
                            CompactibleFreeListSpace* space,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
                            CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
                            CMSMarkStack* mark_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
                            MarkRefsIntoAndScanClosure* cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
    _space(space),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
    _num_dirty_cards(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
    _scan_cl(collector, span, collector->ref_processor(), bit_map,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1484
                 mark_stack, cl) { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
  MarkFromDirtyCardsClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
                            MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
                            CompactibleFreeListSpace* space,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
                            CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
                            OopTaskQueue* work_queue,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
                            Par_MarkRefsIntoAndScanClosure* cl):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
    _space(space),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
    _num_dirty_cards(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    _scan_cl(collector, span, collector->ref_processor(), bit_map,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1495
             work_queue, cl) { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
  void do_MemRegion(MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
  void set_space(CompactibleFreeListSpace* space) { _space = space; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
  size_t num_dirty_cards() { return _num_dirty_cards; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
// This closure is used in the non-product build to check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
// that there are no MemRegions with a certain property.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
class FalseMemRegionClosure: public MemRegionClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  void do_MemRegion(MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
    guarantee(!mr.is_empty(), "Shouldn't be empty");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
    guarantee(false, "Should never be here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
// This closure is used during the precleaning phase
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
// to "carefully" rescan marked objects on dirty cards.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
// It uses MarkRefsIntoAndScanClosure declared in genOopClosures.hpp
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
// to accomplish some of its work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
class ScanMarkedObjectsAgainCarefullyClosure: public ObjectClosureCareful {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
  CMSCollector*                  _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
  MemRegion                      _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
  bool                           _yield;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  Mutex*                         _freelistLock;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
  CMSBitMap*                     _bitMap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  CMSMarkStack*                  _markStack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  MarkRefsIntoAndScanClosure*    _scanningClosure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
  ScanMarkedObjectsAgainCarefullyClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
                                         MemRegion     span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
                                         CMSBitMap* bitMap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
                                         CMSMarkStack*  markStack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
                                         MarkRefsIntoAndScanClosure* cl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
                                         bool should_yield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
    _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    _yield(should_yield),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
    _bitMap(bitMap),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    _markStack(markStack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    _scanningClosure(cl) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
  void do_object(oop p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
    guarantee(false, "call do_object_careful instead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
  size_t      do_object_careful(oop p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
    guarantee(false, "Unexpected caller");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
  size_t      do_object_careful_m(oop p, MemRegion mr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
  void setFreelistLock(Mutex* m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
    _freelistLock = m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    _scanningClosure->set_freelistLock(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
  inline bool do_yield_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
  void do_yield_work();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
class SurvivorSpacePrecleanClosure: public ObjectClosureCareful {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
  CMSCollector*                  _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
  MemRegion                      _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  bool                           _yield;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  CMSBitMap*                     _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
  CMSMarkStack*                  _mark_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  PushAndMarkClosure*            _scanning_closure;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  unsigned int                   _before_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  SurvivorSpacePrecleanClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
                               MemRegion     span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
                               CMSBitMap*    bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
                               CMSMarkStack* mark_stack,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
                               PushAndMarkClosure* cl,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
                               unsigned int  before_count,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
                               bool          should_yield):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
    _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
    _yield(should_yield),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
    _bit_map(bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
    _mark_stack(mark_stack),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
    _scanning_closure(cl),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
    _before_count(before_count)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
  void do_object(oop p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
    guarantee(false, "call do_object_careful instead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  size_t      do_object_careful(oop p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  size_t      do_object_careful_m(oop p, MemRegion mr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
    guarantee(false, "Unexpected caller");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
  inline void do_yield_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
  void do_yield_work();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
// This closure is used to accomplish the sweeping work
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
// after the second checkpoint but before the concurrent reset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
// phase.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
// Terminology
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
//   left hand chunk (LHC) - block of one or more chunks currently being
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
//     coalesced.  The LHC is available for coalescing with a new chunk.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
//   right hand chunk (RHC) - block that is currently being swept that is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
//     free or garbage that can be coalesced with the LHC.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
// _inFreeRange is true if there is currently a LHC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
// _lastFreeRangeCoalesced is true if the LHC consists of more than one chunk.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
// _freeRangeInFreeLists is true if the LHC is in the free lists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
// _freeFinger is the address of the current LHC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
class SweepClosure: public BlkClosureCareful {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  CMSCollector*                  _collector;  // collector doing the work
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  ConcurrentMarkSweepGeneration* _g;    // Generation being swept
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  CompactibleFreeListSpace*      _sp;   // Space being swept
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1620
  HeapWord*                      _limit;// the address at or above which the sweep should stop
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1621
                                        // because we do not expect newly garbage blocks
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1622
                                        // eligible for sweeping past that address.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  Mutex*                         _freelistLock; // Free list lock (in space)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
  CMSBitMap*                     _bitMap;       // Marking bit map (in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
                                                // generation)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
  bool                           _inFreeRange;  // Indicates if we are in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
                                                // midst of a free run
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
  bool                           _freeRangeInFreeLists;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
                                        // Often, we have just found
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
                                        // a free chunk and started
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
                                        // a new free range; we do not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
                                        // eagerly remove this chunk from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
                                        // the free lists unless there is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
                                        // a possibility of coalescing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
                                        // When true, this flag indicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
                                        // that the _freeFinger below
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
                                        // points to a potentially free chunk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
                                        // that may still be in the free lists
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  bool                           _lastFreeRangeCoalesced;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
                                        // free range contains chunks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
                                        // coalesced
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  bool                           _yield;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
                                        // Whether sweeping should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
                                        // done with yields. For instance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
                                        // when done by the foreground
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
                                        // collector we shouldn't yield.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  HeapWord*                      _freeFinger;   // When _inFreeRange is set, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
                                                // pointer to the "left hand
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
                                                // chunk"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  size_t                         _freeRangeSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
                                        // When _inFreeRange is set, this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
                                        // indicates the accumulated size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
                                        // of the "left hand chunk"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
  NOT_PRODUCT(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
    size_t                       _numObjectsFreed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
    size_t                       _numWordsFreed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    size_t                       _numObjectsLive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
    size_t                       _numWordsLive;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    size_t                       _numObjectsAlreadyFree;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
    size_t                       _numWordsAlreadyFree;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
    FreeChunk*                   _last_fc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
  // Code that is common to a free chunk or garbage when
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
  // encountered during sweeping.
7903
c694e52ff9cb 7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents: 7397
diff changeset
  1666
  void do_post_free_or_garbage_chunk(FreeChunk *fc, size_t chunkSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  // Process a free chunk during sweeping.
7903
c694e52ff9cb 7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents: 7397
diff changeset
  1668
  void do_already_free_chunk(FreeChunk *fc);
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1669
  // Work method called when processing an already free or a
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1670
  // freshly garbage chunk to do a lookahead and possibly a
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
  1671
  // preemptive flush if crossing over _limit.
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1672
  void lookahead_and_flush(FreeChunk* fc, size_t chunkSize);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
  // Process a garbage chunk during sweeping.
7903
c694e52ff9cb 7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents: 7397
diff changeset
  1674
  size_t do_garbage_chunk(FreeChunk *fc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  // Process a live chunk during sweeping.
7903
c694e52ff9cb 7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents: 7397
diff changeset
  1676
  size_t do_live_chunk(FreeChunk* fc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
  // Accessors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
  HeapWord* freeFinger() const          { return _freeFinger; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
  void set_freeFinger(HeapWord* v)      { _freeFinger = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
  bool inFreeRange()    const           { return _inFreeRange; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  void set_inFreeRange(bool v)          { _inFreeRange = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  bool lastFreeRangeCoalesced() const    { return _lastFreeRangeCoalesced; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  void set_lastFreeRangeCoalesced(bool v) { _lastFreeRangeCoalesced = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  bool freeRangeInFreeLists() const     { return _freeRangeInFreeLists; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  void set_freeRangeInFreeLists(bool v) { _freeRangeInFreeLists = v; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  // Initialize a free range.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  void initialize_free_range(HeapWord* freeFinger, bool freeRangeInFreeLists);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
  // Return this chunk to the free lists.
7903
c694e52ff9cb 7008136: CMS: assert((HeapWord*)nextChunk <= _limit) failed: sweep invariant
ysr
parents: 7397
diff changeset
  1691
  void flush_cur_free_chunk(HeapWord* chunk, size_t size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
  // Check if we should yield and do so when necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1694
  inline void do_yield_check(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
  // Yield
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
  void do_yield_work(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  // Debugging/Printing
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1700
  void print_free_block_coalesced(FreeChunk* fc) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  SweepClosure(CMSCollector* collector, ConcurrentMarkSweepGeneration* g,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
               CMSBitMap* bitMap, bool should_yield);
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1705
  ~SweepClosure() PRODUCT_RETURN;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
  size_t       do_blk_careful(HeapWord* addr);
9969
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1708
  void         print() const { print_on(tty); }
57932d7294a9 7042740: CMS: assert(n> q) failed: Looping at: ... blockOffsetTable.cpp:557
ysr
parents: 9623
diff changeset
  1709
  void         print_on(outputStream *st) const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
// Closures related to weak references processing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
// During CMS' weak reference processing, this is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1715
// work-routine/closure used to complete transitive
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1716
// marking of objects as live after a certain point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
// in which an initial set has been completely accumulated.
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1718
// This closure is currently used both during the final
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1719
// remark stop-world phase, as well as during the concurrent
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1720
// precleaning of the discovered reference lists.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
class CMSDrainMarkingStackClosure: public VoidClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
  CMSCollector*        _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
  MemRegion            _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  CMSMarkStack*        _mark_stack;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
  CMSBitMap*           _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
  CMSKeepAliveClosure* _keep_alive;
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1727
  bool                 _concurrent_precleaning;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  CMSDrainMarkingStackClosure(CMSCollector* collector, MemRegion span,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
                      CMSBitMap* bit_map, CMSMarkStack* mark_stack,
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1731
                      CMSKeepAliveClosure* keep_alive,
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1732
                      bool cpc):
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
    _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
    _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
    _bit_map(bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
    _mark_stack(mark_stack),
1605
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1737
    _keep_alive(keep_alive),
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1738
    _concurrent_precleaning(cpc) {
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1739
    assert(_concurrent_precleaning == _keep_alive->concurrent_precleaning(),
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1740
           "Mismatch");
6b43d186eb8d 6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents: 1388
diff changeset
  1741
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
  void do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
// A parallel version of CMSDrainMarkingStackClosure above.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
class CMSParDrainMarkingStackClosure: public VoidClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
  CMSCollector*           _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
  MemRegion               _span;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
  OopTaskQueue*           _work_queue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
  CMSBitMap*              _bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
  CMSInnerParMarkAndPushClosure _mark_and_push;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
  CMSParDrainMarkingStackClosure(CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1756
                                 MemRegion span, CMSBitMap* bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
                                 OopTaskQueue* work_queue):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
    _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
    _span(span),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
    _bit_map(bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
    _work_queue(work_queue),
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1762
    _mark_and_push(collector, span, bit_map, work_queue) { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
  void trim_queue(uint max);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
  void do_void();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
// Allow yielding or short-circuiting of reference list
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 18996
diff changeset
  1770
// precleaning work.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
class CMSPrecleanRefsYieldClosure: public YieldClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
  CMSCollector* _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
  void do_yield_work();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
  CMSPrecleanRefsYieldClosure(CMSCollector* collector):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
    _collector(collector) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
  virtual bool should_return();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1779
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
// Convenience class that locks free list locks for given CMS collector
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
class FreelistLocker: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
  CMSCollector* _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  FreelistLocker(CMSCollector* collector):
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
    _collector(collector) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
    _collector->getFreelistLocks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  ~FreelistLocker() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
    _collector->releaseFreelistLocks();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
// Mark all dead objects in a given space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
class MarkDeadObjectsClosure: public BlkClosure {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
  const CMSCollector*             _collector;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  const CompactibleFreeListSpace* _sp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
  CMSBitMap*                      _live_bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
  CMSBitMap*                      _dead_bit_map;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
  MarkDeadObjectsClosure(const CMSCollector* collector,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
                         const CompactibleFreeListSpace* sp,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
                         CMSBitMap *live_bit_map,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
                         CMSBitMap *dead_bit_map) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
    _collector(collector),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
    _sp(sp),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
    _live_bit_map(live_bit_map),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
    _dead_bit_map(dead_bit_map) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  size_t do_blk(HeapWord* addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
};
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1813
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1814
class TraceCMSMemoryManagerStats : public TraceMemoryManagerStats {
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1815
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1816
 public:
9623
151c0b638488 7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents: 8688
diff changeset
  1817
  TraceCMSMemoryManagerStats(CMSCollector::CollectorState phase, GCCause::Cause cause);
6245
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1818
};
c37d2cf6de1a 6581734: CMS Old Gen's collection usage is zero after GC which is incorrect
kevinw
parents: 5547
diff changeset
  1819
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
  1820
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6985
diff changeset
  1821
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CONCURRENTMARKSWEEPGENERATION_HPP