1/*
2 * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#include "precompiled.hpp"
26#include "gc/serial/defNewGeneration.inline.hpp"
27#include "gc/shared/ageTable.inline.hpp"
28#include "gc/shared/cardTableRS.hpp"
29#include "gc/shared/collectorCounters.hpp"
30#include "gc/shared/gcHeapSummary.hpp"
31#include "gc/shared/gcLocker.inline.hpp"
32#include "gc/shared/gcPolicyCounters.hpp"
33#include "gc/shared/gcTimer.hpp"
34#include "gc/shared/gcTrace.hpp"
35#include "gc/shared/gcTraceTime.inline.hpp"
36#include "gc/shared/genCollectedHeap.hpp"
37#include "gc/shared/genOopClosures.inline.hpp"
38#include "gc/shared/generationSpec.hpp"
39#include "gc/shared/preservedMarks.inline.hpp"
40#include "gc/shared/referencePolicy.hpp"
41#include "gc/shared/space.inline.hpp"
42#include "gc/shared/spaceDecorator.hpp"
43#include "gc/shared/strongRootsScope.hpp"
44#include "logging/log.hpp"
45#include "memory/iterator.hpp"
46#include "memory/resourceArea.hpp"
47#include "oops/instanceRefKlass.hpp"
48#include "oops/oop.inline.hpp"
49#include "runtime/atomic.hpp"
50#include "runtime/java.hpp"
51#include "runtime/prefetch.inline.hpp"
52#include "runtime/thread.inline.hpp"
53#include "utilities/copy.hpp"
54#include "utilities/globalDefinitions.hpp"
55#include "utilities/stack.inline.hpp"
56#if INCLUDE_ALL_GCS
57#include "gc/cms/parOopClosures.hpp"
58#endif
59
60//
61// DefNewGeneration functions.
62
63// Methods of protected closure types.
64
65DefNewGeneration::IsAliveClosure::IsAliveClosure(Generation* young_gen) : _young_gen(young_gen) {
66  assert(_young_gen->kind() == Generation::ParNew ||
67         _young_gen->kind() == Generation::DefNew, "Expected the young generation here");
68}
69
70bool DefNewGeneration::IsAliveClosure::do_object_b(oop p) {
71  return (HeapWord*)p >= _young_gen->reserved().end() || p->is_forwarded();
72}
73
74DefNewGeneration::KeepAliveClosure::
75KeepAliveClosure(ScanWeakRefClosure* cl) : _cl(cl) {
76  _rs = GenCollectedHeap::heap()->rem_set();
77}
78
79void DefNewGeneration::KeepAliveClosure::do_oop(oop* p)       { DefNewGeneration::KeepAliveClosure::do_oop_work(p); }
80void DefNewGeneration::KeepAliveClosure::do_oop(narrowOop* p) { DefNewGeneration::KeepAliveClosure::do_oop_work(p); }
81
82
83DefNewGeneration::FastKeepAliveClosure::
84FastKeepAliveClosure(DefNewGeneration* g, ScanWeakRefClosure* cl) :
85  DefNewGeneration::KeepAliveClosure(cl) {
86  _boundary = g->reserved().end();
87}
88
89void DefNewGeneration::FastKeepAliveClosure::do_oop(oop* p)       { DefNewGeneration::FastKeepAliveClosure::do_oop_work(p); }
90void DefNewGeneration::FastKeepAliveClosure::do_oop(narrowOop* p) { DefNewGeneration::FastKeepAliveClosure::do_oop_work(p); }
91
92DefNewGeneration::EvacuateFollowersClosure::
93EvacuateFollowersClosure(GenCollectedHeap* gch,
94                         ScanClosure* cur,
95                         ScanClosure* older) :
96  _gch(gch), _scan_cur_or_nonheap(cur), _scan_older(older)
97{}
98
99void DefNewGeneration::EvacuateFollowersClosure::do_void() {
100  do {
101    _gch->oop_since_save_marks_iterate(GenCollectedHeap::YoungGen, _scan_cur_or_nonheap, _scan_older);
102  } while (!_gch->no_allocs_since_save_marks());
103}
104
105DefNewGeneration::FastEvacuateFollowersClosure::
106FastEvacuateFollowersClosure(GenCollectedHeap* gch,
107                             FastScanClosure* cur,
108                             FastScanClosure* older) :
109  _gch(gch), _scan_cur_or_nonheap(cur), _scan_older(older)
110{
111  assert(_gch->young_gen()->kind() == Generation::DefNew, "Generation should be DefNew");
112  _young_gen = (DefNewGeneration*)_gch->young_gen();
113}
114
115void DefNewGeneration::FastEvacuateFollowersClosure::do_void() {
116  do {
117    _gch->oop_since_save_marks_iterate(GenCollectedHeap::YoungGen, _scan_cur_or_nonheap, _scan_older);
118  } while (!_gch->no_allocs_since_save_marks());
119  guarantee(_young_gen->promo_failure_scan_is_complete(), "Failed to finish scan");
120}
121
122ScanClosure::ScanClosure(DefNewGeneration* g, bool gc_barrier) :
123    OopsInKlassOrGenClosure(g), _g(g), _gc_barrier(gc_barrier)
124{
125  _boundary = _g->reserved().end();
126}
127
128void ScanClosure::do_oop(oop* p)       { ScanClosure::do_oop_work(p); }
129void ScanClosure::do_oop(narrowOop* p) { ScanClosure::do_oop_work(p); }
130
131FastScanClosure::FastScanClosure(DefNewGeneration* g, bool gc_barrier) :
132    OopsInKlassOrGenClosure(g), _g(g), _gc_barrier(gc_barrier)
133{
134  _boundary = _g->reserved().end();
135}
136
137void FastScanClosure::do_oop(oop* p)       { FastScanClosure::do_oop_work(p); }
138void FastScanClosure::do_oop(narrowOop* p) { FastScanClosure::do_oop_work(p); }
139
140void KlassScanClosure::do_klass(Klass* klass) {
141  NOT_PRODUCT(ResourceMark rm);
142  log_develop_trace(gc, scavenge)("KlassScanClosure::do_klass " PTR_FORMAT ", %s, dirty: %s",
143                                  p2i(klass),
144                                  klass->external_name(),
145                                  klass->has_modified_oops() ? "true" : "false");
146
147  // If the klass has not been dirtied we know that there's
148  // no references into  the young gen and we can skip it.
149  if (klass->has_modified_oops()) {
150    if (_accumulate_modified_oops) {
151      klass->accumulate_modified_oops();
152    }
153
154    // Clear this state since we're going to scavenge all the metadata.
155    klass->clear_modified_oops();
156
157    // Tell the closure which Klass is being scanned so that it can be dirtied
158    // if oops are left pointing into the young gen.
159    _scavenge_closure->set_scanned_klass(klass);
160
161    klass->oops_do(_scavenge_closure);
162
163    _scavenge_closure->set_scanned_klass(NULL);
164  }
165}
166
167ScanWeakRefClosure::ScanWeakRefClosure(DefNewGeneration* g) :
168  _g(g)
169{
170  _boundary = _g->reserved().end();
171}
172
173void ScanWeakRefClosure::do_oop(oop* p)       { ScanWeakRefClosure::do_oop_work(p); }
174void ScanWeakRefClosure::do_oop(narrowOop* p) { ScanWeakRefClosure::do_oop_work(p); }
175
176void FilteringClosure::do_oop(oop* p)       { FilteringClosure::do_oop_work(p); }
177void FilteringClosure::do_oop(narrowOop* p) { FilteringClosure::do_oop_work(p); }
178
179KlassScanClosure::KlassScanClosure(OopsInKlassOrGenClosure* scavenge_closure,
180                                   KlassRemSet* klass_rem_set)
181    : _scavenge_closure(scavenge_closure),
182      _accumulate_modified_oops(klass_rem_set->accumulate_modified_oops()) {}
183
184
185DefNewGeneration::DefNewGeneration(ReservedSpace rs,
186                                   size_t initial_size,
187                                   const char* policy)
188  : Generation(rs, initial_size),
189    _preserved_marks_set(false /* in_c_heap */),
190    _promo_failure_drain_in_progress(false),
191    _should_allocate_from_space(false)
192{
193  MemRegion cmr((HeapWord*)_virtual_space.low(),
194                (HeapWord*)_virtual_space.high());
195  GenCollectedHeap* gch = GenCollectedHeap::heap();
196
197  gch->barrier_set()->resize_covered_region(cmr);
198
199  _eden_space = new ContiguousSpace();
200  _from_space = new ContiguousSpace();
201  _to_space   = new ContiguousSpace();
202
203  if (_eden_space == NULL || _from_space == NULL || _to_space == NULL) {
204    vm_exit_during_initialization("Could not allocate a new gen space");
205  }
206
207  // Compute the maximum eden and survivor space sizes. These sizes
208  // are computed assuming the entire reserved space is committed.
209  // These values are exported as performance counters.
210  uintx alignment = gch->collector_policy()->space_alignment();
211  uintx size = _virtual_space.reserved_size();
212  _max_survivor_size = compute_survivor_size(size, alignment);
213  _max_eden_size = size - (2*_max_survivor_size);
214
215  // allocate the performance counters
216  GenCollectorPolicy* gcp = gch->gen_policy();
217
218  // Generation counters -- generation 0, 3 subspaces
219  _gen_counters = new GenerationCounters("new", 0, 3,
220      gcp->min_young_size(), gcp->max_young_size(), &_virtual_space);
221  _gc_counters = new CollectorCounters(policy, 0);
222
223  _eden_counters = new CSpaceCounters("eden", 0, _max_eden_size, _eden_space,
224                                      _gen_counters);
225  _from_counters = new CSpaceCounters("s0", 1, _max_survivor_size, _from_space,
226                                      _gen_counters);
227  _to_counters = new CSpaceCounters("s1", 2, _max_survivor_size, _to_space,
228                                    _gen_counters);
229
230  compute_space_boundaries(0, SpaceDecorator::Clear, SpaceDecorator::Mangle);
231  update_counters();
232  _old_gen = NULL;
233  _tenuring_threshold = MaxTenuringThreshold;
234  _pretenure_size_threshold_words = PretenureSizeThreshold >> LogHeapWordSize;
235
236  _gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
237}
238
239void DefNewGeneration::compute_space_boundaries(uintx minimum_eden_size,
240                                                bool clear_space,
241                                                bool mangle_space) {
242  uintx alignment =
243    GenCollectedHeap::heap()->collector_policy()->space_alignment();
244
245  // If the spaces are being cleared (only done at heap initialization
246  // currently), the survivor spaces need not be empty.
247  // Otherwise, no care is taken for used areas in the survivor spaces
248  // so check.
249  assert(clear_space || (to()->is_empty() && from()->is_empty()),
250    "Initialization of the survivor spaces assumes these are empty");
251
252  // Compute sizes
253  uintx size = _virtual_space.committed_size();
254  uintx survivor_size = compute_survivor_size(size, alignment);
255  uintx eden_size = size - (2*survivor_size);
256  assert(eden_size > 0 && survivor_size <= eden_size, "just checking");
257
258  if (eden_size < minimum_eden_size) {
259    // May happen due to 64Kb rounding, if so adjust eden size back up
260    minimum_eden_size = align_size_up(minimum_eden_size, alignment);
261    uintx maximum_survivor_size = (size - minimum_eden_size) / 2;
262    uintx unaligned_survivor_size =
263      align_size_down(maximum_survivor_size, alignment);
264    survivor_size = MAX2(unaligned_survivor_size, alignment);
265    eden_size = size - (2*survivor_size);
266    assert(eden_size > 0 && survivor_size <= eden_size, "just checking");
267    assert(eden_size >= minimum_eden_size, "just checking");
268  }
269
270  char *eden_start = _virtual_space.low();
271  char *from_start = eden_start + eden_size;
272  char *to_start   = from_start + survivor_size;
273  char *to_end     = to_start   + survivor_size;
274
275  assert(to_end == _virtual_space.high(), "just checking");
276  assert(Space::is_aligned((HeapWord*)eden_start), "checking alignment");
277  assert(Space::is_aligned((HeapWord*)from_start), "checking alignment");
278  assert(Space::is_aligned((HeapWord*)to_start),   "checking alignment");
279
280  MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)from_start);
281  MemRegion fromMR((HeapWord*)from_start, (HeapWord*)to_start);
282  MemRegion toMR  ((HeapWord*)to_start, (HeapWord*)to_end);
283
284  // A minimum eden size implies that there is a part of eden that
285  // is being used and that affects the initialization of any
286  // newly formed eden.
287  bool live_in_eden = minimum_eden_size > 0;
288
289  // If not clearing the spaces, do some checking to verify that
290  // the space are already mangled.
291  if (!clear_space) {
292    // Must check mangling before the spaces are reshaped.  Otherwise,
293    // the bottom or end of one space may have moved into another
294    // a failure of the check may not correctly indicate which space
295    // is not properly mangled.
296    if (ZapUnusedHeapArea) {
297      HeapWord* limit = (HeapWord*) _virtual_space.high();
298      eden()->check_mangled_unused_area(limit);
299      from()->check_mangled_unused_area(limit);
300        to()->check_mangled_unused_area(limit);
301    }
302  }
303
304  // Reset the spaces for their new regions.
305  eden()->initialize(edenMR,
306                     clear_space && !live_in_eden,
307                     SpaceDecorator::Mangle);
308  // If clear_space and live_in_eden, we will not have cleared any
309  // portion of eden above its top. This can cause newly
310  // expanded space not to be mangled if using ZapUnusedHeapArea.
311  // We explicitly do such mangling here.
312  if (ZapUnusedHeapArea && clear_space && live_in_eden && mangle_space) {
313    eden()->mangle_unused_area();
314  }
315  from()->initialize(fromMR, clear_space, mangle_space);
316  to()->initialize(toMR, clear_space, mangle_space);
317
318  // Set next compaction spaces.
319  eden()->set_next_compaction_space(from());
320  // The to-space is normally empty before a compaction so need
321  // not be considered.  The exception is during promotion
322  // failure handling when to-space can contain live objects.
323  from()->set_next_compaction_space(NULL);
324}
325
326void DefNewGeneration::swap_spaces() {
327  ContiguousSpace* s = from();
328  _from_space        = to();
329  _to_space          = s;
330  eden()->set_next_compaction_space(from());
331  // The to-space is normally empty before a compaction so need
332  // not be considered.  The exception is during promotion
333  // failure handling when to-space can contain live objects.
334  from()->set_next_compaction_space(NULL);
335
336  if (UsePerfData) {
337    CSpaceCounters* c = _from_counters;
338    _from_counters = _to_counters;
339    _to_counters = c;
340  }
341}
342
343bool DefNewGeneration::expand(size_t bytes) {
344  MutexLocker x(ExpandHeap_lock);
345  HeapWord* prev_high = (HeapWord*) _virtual_space.high();
346  bool success = _virtual_space.expand_by(bytes);
347  if (success && ZapUnusedHeapArea) {
348    // Mangle newly committed space immediately because it
349    // can be done here more simply that after the new
350    // spaces have been computed.
351    HeapWord* new_high = (HeapWord*) _virtual_space.high();
352    MemRegion mangle_region(prev_high, new_high);
353    SpaceMangler::mangle_region(mangle_region);
354  }
355
356  // Do not attempt an expand-to-the reserve size.  The
357  // request should properly observe the maximum size of
358  // the generation so an expand-to-reserve should be
359  // unnecessary.  Also a second call to expand-to-reserve
360  // value potentially can cause an undue expansion.
361  // For example if the first expand fail for unknown reasons,
362  // but the second succeeds and expands the heap to its maximum
363  // value.
364  if (GCLocker::is_active()) {
365    log_debug(gc)("Garbage collection disabled, expanded heap instead");
366  }
367
368  return success;
369}
370
371size_t DefNewGeneration::adjust_for_thread_increase(size_t new_size_candidate,
372                                                    size_t new_size_before,
373                                                    size_t alignment) const {
374  size_t desired_new_size = new_size_before;
375
376  if (NewSizeThreadIncrease > 0) {
377    int threads_count;
378    size_t thread_increase_size = 0;
379
380    // 1. Check an overflow at 'threads_count * NewSizeThreadIncrease'.
381    threads_count = Threads::number_of_non_daemon_threads();
382    if (threads_count > 0 && NewSizeThreadIncrease <= max_uintx / threads_count) {
383      thread_increase_size = threads_count * NewSizeThreadIncrease;
384
385      // 2. Check an overflow at 'new_size_candidate + thread_increase_size'.
386      if (new_size_candidate <= max_uintx - thread_increase_size) {
387        new_size_candidate += thread_increase_size;
388
389        // 3. Check an overflow at 'align_size_up'.
390        size_t aligned_max = ((max_uintx - alignment) & ~(alignment-1));
391        if (new_size_candidate <= aligned_max) {
392          desired_new_size = align_size_up(new_size_candidate, alignment);
393        }
394      }
395    }
396  }
397
398  return desired_new_size;
399}
400
401void DefNewGeneration::compute_new_size() {
402  // This is called after a GC that includes the old generation, so from-space
403  // will normally be empty.
404  // Note that we check both spaces, since if scavenge failed they revert roles.
405  // If not we bail out (otherwise we would have to relocate the objects).
406  if (!from()->is_empty() || !to()->is_empty()) {
407    return;
408  }
409
410  GenCollectedHeap* gch = GenCollectedHeap::heap();
411
412  size_t old_size = gch->old_gen()->capacity();
413  size_t new_size_before = _virtual_space.committed_size();
414  size_t min_new_size = initial_size();
415  size_t max_new_size = reserved().byte_size();
416  assert(min_new_size <= new_size_before &&
417         new_size_before <= max_new_size,
418         "just checking");
419  // All space sizes must be multiples of Generation::GenGrain.
420  size_t alignment = Generation::GenGrain;
421
422  int threads_count = 0;
423  size_t thread_increase_size = 0;
424
425  size_t new_size_candidate = old_size / NewRatio;
426  // Compute desired new generation size based on NewRatio and NewSizeThreadIncrease
427  // and reverts to previous value if any overflow happens
428  size_t desired_new_size = adjust_for_thread_increase(new_size_candidate, new_size_before, alignment);
429
430  // Adjust new generation size
431  desired_new_size = MAX2(MIN2(desired_new_size, max_new_size), min_new_size);
432  assert(desired_new_size <= max_new_size, "just checking");
433
434  bool changed = false;
435  if (desired_new_size > new_size_before) {
436    size_t change = desired_new_size - new_size_before;
437    assert(change % alignment == 0, "just checking");
438    if (expand(change)) {
439       changed = true;
440    }
441    // If the heap failed to expand to the desired size,
442    // "changed" will be false.  If the expansion failed
443    // (and at this point it was expected to succeed),
444    // ignore the failure (leaving "changed" as false).
445  }
446  if (desired_new_size < new_size_before && eden()->is_empty()) {
447    // bail out of shrinking if objects in eden
448    size_t change = new_size_before - desired_new_size;
449    assert(change % alignment == 0, "just checking");
450    _virtual_space.shrink_by(change);
451    changed = true;
452  }
453  if (changed) {
454    // The spaces have already been mangled at this point but
455    // may not have been cleared (set top = bottom) and should be.
456    // Mangling was done when the heap was being expanded.
457    compute_space_boundaries(eden()->used(),
458                             SpaceDecorator::Clear,
459                             SpaceDecorator::DontMangle);
460    MemRegion cmr((HeapWord*)_virtual_space.low(),
461                  (HeapWord*)_virtual_space.high());
462    gch->barrier_set()->resize_covered_region(cmr);
463
464    log_debug(gc, ergo, heap)(
465        "New generation size " SIZE_FORMAT "K->" SIZE_FORMAT "K [eden=" SIZE_FORMAT "K,survivor=" SIZE_FORMAT "K]",
466        new_size_before/K, _virtual_space.committed_size()/K,
467        eden()->capacity()/K, from()->capacity()/K);
468    log_trace(gc, ergo, heap)(
469        "  [allowed " SIZE_FORMAT "K extra for %d threads]",
470          thread_increase_size/K, threads_count);
471      }
472}
473
474void DefNewGeneration::younger_refs_iterate(OopsInGenClosure* cl, uint n_threads) {
475  assert(false, "NYI -- are you sure you want to call this?");
476}
477
478
479size_t DefNewGeneration::capacity() const {
480  return eden()->capacity()
481       + from()->capacity();  // to() is only used during scavenge
482}
483
484
485size_t DefNewGeneration::used() const {
486  return eden()->used()
487       + from()->used();      // to() is only used during scavenge
488}
489
490
491size_t DefNewGeneration::free() const {
492  return eden()->free()
493       + from()->free();      // to() is only used during scavenge
494}
495
496size_t DefNewGeneration::max_capacity() const {
497  const size_t alignment = GenCollectedHeap::heap()->collector_policy()->space_alignment();
498  const size_t reserved_bytes = reserved().byte_size();
499  return reserved_bytes - compute_survivor_size(reserved_bytes, alignment);
500}
501
502size_t DefNewGeneration::unsafe_max_alloc_nogc() const {
503  return eden()->free();
504}
505
506size_t DefNewGeneration::capacity_before_gc() const {
507  return eden()->capacity();
508}
509
510size_t DefNewGeneration::contiguous_available() const {
511  return eden()->free();
512}
513
514
515HeapWord* volatile* DefNewGeneration::top_addr() const { return eden()->top_addr(); }
516HeapWord** DefNewGeneration::end_addr() const { return eden()->end_addr(); }
517
518void DefNewGeneration::object_iterate(ObjectClosure* blk) {
519  eden()->object_iterate(blk);
520  from()->object_iterate(blk);
521}
522
523
524void DefNewGeneration::space_iterate(SpaceClosure* blk,
525                                     bool usedOnly) {
526  blk->do_space(eden());
527  blk->do_space(from());
528  blk->do_space(to());
529}
530
531// The last collection bailed out, we are running out of heap space,
532// so we try to allocate the from-space, too.
533HeapWord* DefNewGeneration::allocate_from_space(size_t size) {
534  bool should_try_alloc = should_allocate_from_space() || GCLocker::is_active_and_needs_gc();
535
536  // If the Heap_lock is not locked by this thread, this will be called
537  // again later with the Heap_lock held.
538  bool do_alloc = should_try_alloc && (Heap_lock->owned_by_self() || (SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()));
539
540  HeapWord* result = NULL;
541  if (do_alloc) {
542    result = from()->allocate(size);
543  }
544
545  log_trace(gc, alloc)("DefNewGeneration::allocate_from_space(" SIZE_FORMAT "):  will_fail: %s  heap_lock: %s  free: " SIZE_FORMAT "%s%s returns %s",
546                        size,
547                        GenCollectedHeap::heap()->incremental_collection_will_fail(false /* don't consult_young */) ?
548                          "true" : "false",
549                        Heap_lock->is_locked() ? "locked" : "unlocked",
550                        from()->free(),
551                        should_try_alloc ? "" : "  should_allocate_from_space: NOT",
552                        do_alloc ? "  Heap_lock is not owned by self" : "",
553                        result == NULL ? "NULL" : "object");
554
555  return result;
556}
557
558HeapWord* DefNewGeneration::expand_and_allocate(size_t size,
559                                                bool   is_tlab,
560                                                bool   parallel) {
561  // We don't attempt to expand the young generation (but perhaps we should.)
562  return allocate(size, is_tlab);
563}
564
565void DefNewGeneration::adjust_desired_tenuring_threshold() {
566  // Set the desired survivor size to half the real survivor space
567  size_t const survivor_capacity = to()->capacity() / HeapWordSize;
568  size_t const desired_survivor_size = (size_t)((((double)survivor_capacity) * TargetSurvivorRatio) / 100);
569
570  _tenuring_threshold = age_table()->compute_tenuring_threshold(desired_survivor_size);
571
572  if (UsePerfData) {
573    GCPolicyCounters* gc_counters = GenCollectedHeap::heap()->gen_policy()->counters();
574    gc_counters->tenuring_threshold()->set_value(_tenuring_threshold);
575    gc_counters->desired_survivor_size()->set_value(desired_survivor_size * oopSize);
576  }
577
578  age_table()->print_age_table(_tenuring_threshold);
579}
580
581void DefNewGeneration::collect(bool   full,
582                               bool   clear_all_soft_refs,
583                               size_t size,
584                               bool   is_tlab) {
585  assert(full || size > 0, "otherwise we don't want to collect");
586
587  GenCollectedHeap* gch = GenCollectedHeap::heap();
588
589  _gc_timer->register_gc_start();
590  DefNewTracer gc_tracer;
591  gc_tracer.report_gc_start(gch->gc_cause(), _gc_timer->gc_start());
592
593  _old_gen = gch->old_gen();
594
595  // If the next generation is too full to accommodate promotion
596  // from this generation, pass on collection; let the next generation
597  // do it.
598  if (!collection_attempt_is_safe()) {
599    log_trace(gc)(":: Collection attempt not safe ::");
600    gch->set_incremental_collection_failed(); // Slight lie: we did not even attempt one
601    return;
602  }
603  assert(to()->is_empty(), "Else not collection_attempt_is_safe");
604
605  init_assuming_no_promotion_failure();
606
607  GCTraceTime(Trace, gc, phases) tm("DefNew", NULL, gch->gc_cause());
608
609  gch->trace_heap_before_gc(&gc_tracer);
610
611  // These can be shared for all code paths
612  IsAliveClosure is_alive(this);
613  ScanWeakRefClosure scan_weak_ref(this);
614
615  age_table()->clear();
616  to()->clear(SpaceDecorator::Mangle);
617  // The preserved marks should be empty at the start of the GC.
618  _preserved_marks_set.init(1);
619
620  gch->rem_set()->prepare_for_younger_refs_iterate(false);
621
622  assert(gch->no_allocs_since_save_marks(),
623         "save marks have not been newly set.");
624
625  // Not very pretty.
626  CollectorPolicy* cp = gch->collector_policy();
627
628  FastScanClosure fsc_with_no_gc_barrier(this, false);
629  FastScanClosure fsc_with_gc_barrier(this, true);
630
631  KlassScanClosure klass_scan_closure(&fsc_with_no_gc_barrier,
632                                      gch->rem_set()->klass_rem_set());
633  CLDToKlassAndOopClosure cld_scan_closure(&klass_scan_closure,
634                                           &fsc_with_no_gc_barrier,
635                                           false);
636
637  set_promo_failure_scan_stack_closure(&fsc_with_no_gc_barrier);
638  FastEvacuateFollowersClosure evacuate_followers(gch,
639                                                  &fsc_with_no_gc_barrier,
640                                                  &fsc_with_gc_barrier);
641
642  assert(gch->no_allocs_since_save_marks(),
643         "save marks have not been newly set.");
644
645  {
646    // DefNew needs to run with n_threads == 0, to make sure the serial
647    // version of the card table scanning code is used.
648    // See: CardTableModRefBSForCTRS::non_clean_card_iterate_possibly_parallel.
649    StrongRootsScope srs(0);
650
651    gch->young_process_roots(&srs,
652                             &fsc_with_no_gc_barrier,
653                             &fsc_with_gc_barrier,
654                             &cld_scan_closure);
655  }
656
657  // "evacuate followers".
658  evacuate_followers.do_void();
659
660  FastKeepAliveClosure keep_alive(this, &scan_weak_ref);
661  ReferenceProcessor* rp = ref_processor();
662  rp->setup_policy(clear_all_soft_refs);
663  const ReferenceProcessorStats& stats =
664  rp->process_discovered_references(&is_alive, &keep_alive, &evacuate_followers,
665                                    NULL, _gc_timer);
666  gc_tracer.report_gc_reference_stats(stats);
667  gc_tracer.report_tenuring_threshold(tenuring_threshold());
668
669  if (!_promotion_failed) {
670    // Swap the survivor spaces.
671    eden()->clear(SpaceDecorator::Mangle);
672    from()->clear(SpaceDecorator::Mangle);
673    if (ZapUnusedHeapArea) {
674      // This is now done here because of the piece-meal mangling which
675      // can check for valid mangling at intermediate points in the
676      // collection(s).  When a young collection fails to collect
677      // sufficient space resizing of the young generation can occur
678      // an redistribute the spaces in the young generation.  Mangle
679      // here so that unzapped regions don't get distributed to
680      // other spaces.
681      to()->mangle_unused_area();
682    }
683    swap_spaces();
684
685    assert(to()->is_empty(), "to space should be empty now");
686
687    adjust_desired_tenuring_threshold();
688
689    // A successful scavenge should restart the GC time limit count which is
690    // for full GC's.
691    AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy();
692    size_policy->reset_gc_overhead_limit_count();
693    assert(!gch->incremental_collection_failed(), "Should be clear");
694  } else {
695    assert(_promo_failure_scan_stack.is_empty(), "post condition");
696    _promo_failure_scan_stack.clear(true); // Clear cached segments.
697
698    remove_forwarding_pointers();
699    log_info(gc, promotion)("Promotion failed");
700    // Add to-space to the list of space to compact
701    // when a promotion failure has occurred.  In that
702    // case there can be live objects in to-space
703    // as a result of a partial evacuation of eden
704    // and from-space.
705    swap_spaces();   // For uniformity wrt ParNewGeneration.
706    from()->set_next_compaction_space(to());
707    gch->set_incremental_collection_failed();
708
709    // Inform the next generation that a promotion failure occurred.
710    _old_gen->promotion_failure_occurred();
711    gc_tracer.report_promotion_failed(_promotion_failed_info);
712
713    // Reset the PromotionFailureALot counters.
714    NOT_PRODUCT(gch->reset_promotion_should_fail();)
715  }
716  // We should have processed and cleared all the preserved marks.
717  _preserved_marks_set.reclaim();
718  // set new iteration safe limit for the survivor spaces
719  from()->set_concurrent_iteration_safe_limit(from()->top());
720  to()->set_concurrent_iteration_safe_limit(to()->top());
721
722  // We need to use a monotonically non-decreasing time in ms
723  // or we will see time-warp warnings and os::javaTimeMillis()
724  // does not guarantee monotonicity.
725  jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
726  update_time_of_last_gc(now);
727
728  gch->trace_heap_after_gc(&gc_tracer);
729
730  _gc_timer->register_gc_end();
731
732  gc_tracer.report_gc_end(_gc_timer->gc_end(), _gc_timer->time_partitions());
733}
734
735void DefNewGeneration::init_assuming_no_promotion_failure() {
736  _promotion_failed = false;
737  _promotion_failed_info.reset();
738  from()->set_next_compaction_space(NULL);
739}
740
741void DefNewGeneration::remove_forwarding_pointers() {
742  RemoveForwardedPointerClosure rspc;
743  eden()->object_iterate(&rspc);
744  from()->object_iterate(&rspc);
745
746  SharedRestorePreservedMarksTaskExecutor task_executor(GenCollectedHeap::heap()->workers());
747  _preserved_marks_set.restore(&task_executor);
748}
749
750void DefNewGeneration::handle_promotion_failure(oop old) {
751  log_debug(gc, promotion)("Promotion failure size = %d) ", old->size());
752
753  _promotion_failed = true;
754  _promotion_failed_info.register_copy_failure(old->size());
755  _preserved_marks_set.get()->push_if_necessary(old, old->mark());
756  // forward to self
757  old->forward_to(old);
758
759  _promo_failure_scan_stack.push(old);
760
761  if (!_promo_failure_drain_in_progress) {
762    // prevent recursion in copy_to_survivor_space()
763    _promo_failure_drain_in_progress = true;
764    drain_promo_failure_scan_stack();
765    _promo_failure_drain_in_progress = false;
766  }
767}
768
769oop DefNewGeneration::copy_to_survivor_space(oop old) {
770  assert(is_in_reserved(old) && !old->is_forwarded(),
771         "shouldn't be scavenging this oop");
772  size_t s = old->size();
773  oop obj = NULL;
774
775  // Try allocating obj in to-space (unless too old)
776  if (old->age() < tenuring_threshold()) {
777    obj = (oop) to()->allocate_aligned(s);
778  }
779
780  // Otherwise try allocating obj tenured
781  if (obj == NULL) {
782    obj = _old_gen->promote(old, s);
783    if (obj == NULL) {
784      handle_promotion_failure(old);
785      return old;
786    }
787  } else {
788    // Prefetch beyond obj
789    const intx interval = PrefetchCopyIntervalInBytes;
790    Prefetch::write(obj, interval);
791
792    // Copy obj
793    Copy::aligned_disjoint_words((HeapWord*)old, (HeapWord*)obj, s);
794
795    // Increment age if obj still in new generation
796    obj->incr_age();
797    age_table()->add(obj, s);
798  }
799
800  // Done, insert forward pointer to obj in this header
801  old->forward_to(obj);
802
803  return obj;
804}
805
806void DefNewGeneration::drain_promo_failure_scan_stack() {
807  while (!_promo_failure_scan_stack.is_empty()) {
808     oop obj = _promo_failure_scan_stack.pop();
809     obj->oop_iterate(_promo_failure_scan_stack_closure);
810  }
811}
812
813void DefNewGeneration::save_marks() {
814  eden()->set_saved_mark();
815  to()->set_saved_mark();
816  from()->set_saved_mark();
817}
818
819
820void DefNewGeneration::reset_saved_marks() {
821  eden()->reset_saved_mark();
822  to()->reset_saved_mark();
823  from()->reset_saved_mark();
824}
825
826
827bool DefNewGeneration::no_allocs_since_save_marks() {
828  assert(eden()->saved_mark_at_top(), "Violated spec - alloc in eden");
829  assert(from()->saved_mark_at_top(), "Violated spec - alloc in from");
830  return to()->saved_mark_at_top();
831}
832
833#define DefNew_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
834                                                                \
835void DefNewGeneration::                                         \
836oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) {   \
837  cl->set_generation(this);                                     \
838  eden()->oop_since_save_marks_iterate##nv_suffix(cl);          \
839  to()->oop_since_save_marks_iterate##nv_suffix(cl);            \
840  from()->oop_since_save_marks_iterate##nv_suffix(cl);          \
841  cl->reset_generation();                                       \
842  save_marks();                                                 \
843}
844
845ALL_SINCE_SAVE_MARKS_CLOSURES(DefNew_SINCE_SAVE_MARKS_DEFN)
846
847#undef DefNew_SINCE_SAVE_MARKS_DEFN
848
849void DefNewGeneration::contribute_scratch(ScratchBlock*& list, Generation* requestor,
850                                         size_t max_alloc_words) {
851  if (requestor == this || _promotion_failed) {
852    return;
853  }
854  assert(GenCollectedHeap::heap()->is_old_gen(requestor), "We should not call our own generation");
855
856  /* $$$ Assert this?  "trace" is a "MarkSweep" function so that's not appropriate.
857  if (to_space->top() > to_space->bottom()) {
858    trace("to_space not empty when contribute_scratch called");
859  }
860  */
861
862  ContiguousSpace* to_space = to();
863  assert(to_space->end() >= to_space->top(), "pointers out of order");
864  size_t free_words = pointer_delta(to_space->end(), to_space->top());
865  if (free_words >= MinFreeScratchWords) {
866    ScratchBlock* sb = (ScratchBlock*)to_space->top();
867    sb->num_words = free_words;
868    sb->next = list;
869    list = sb;
870  }
871}
872
873void DefNewGeneration::reset_scratch() {
874  // If contributing scratch in to_space, mangle all of
875  // to_space if ZapUnusedHeapArea.  This is needed because
876  // top is not maintained while using to-space as scratch.
877  if (ZapUnusedHeapArea) {
878    to()->mangle_unused_area_complete();
879  }
880}
881
882bool DefNewGeneration::collection_attempt_is_safe() {
883  if (!to()->is_empty()) {
884    log_trace(gc)(":: to is not empty ::");
885    return false;
886  }
887  if (_old_gen == NULL) {
888    GenCollectedHeap* gch = GenCollectedHeap::heap();
889    _old_gen = gch->old_gen();
890  }
891  return _old_gen->promotion_attempt_is_safe(used());
892}
893
894void DefNewGeneration::gc_epilogue(bool full) {
895  DEBUG_ONLY(static bool seen_incremental_collection_failed = false;)
896
897  assert(!GCLocker::is_active(), "We should not be executing here");
898  // Check if the heap is approaching full after a collection has
899  // been done.  Generally the young generation is empty at
900  // a minimum at the end of a collection.  If it is not, then
901  // the heap is approaching full.
902  GenCollectedHeap* gch = GenCollectedHeap::heap();
903  if (full) {
904    DEBUG_ONLY(seen_incremental_collection_failed = false;)
905    if (!collection_attempt_is_safe() && !_eden_space->is_empty()) {
906      log_trace(gc)("DefNewEpilogue: cause(%s), full, not safe, set_failed, set_alloc_from, clear_seen",
907                            GCCause::to_string(gch->gc_cause()));
908      gch->set_incremental_collection_failed(); // Slight lie: a full gc left us in that state
909      set_should_allocate_from_space(); // we seem to be running out of space
910    } else {
911      log_trace(gc)("DefNewEpilogue: cause(%s), full, safe, clear_failed, clear_alloc_from, clear_seen",
912                            GCCause::to_string(gch->gc_cause()));
913      gch->clear_incremental_collection_failed(); // We just did a full collection
914      clear_should_allocate_from_space(); // if set
915    }
916  } else {
917#ifdef ASSERT
918    // It is possible that incremental_collection_failed() == true
919    // here, because an attempted scavenge did not succeed. The policy
920    // is normally expected to cause a full collection which should
921    // clear that condition, so we should not be here twice in a row
922    // with incremental_collection_failed() == true without having done
923    // a full collection in between.
924    if (!seen_incremental_collection_failed &&
925        gch->incremental_collection_failed()) {
926      log_trace(gc)("DefNewEpilogue: cause(%s), not full, not_seen_failed, failed, set_seen_failed",
927                            GCCause::to_string(gch->gc_cause()));
928      seen_incremental_collection_failed = true;
929    } else if (seen_incremental_collection_failed) {
930      log_trace(gc)("DefNewEpilogue: cause(%s), not full, seen_failed, will_clear_seen_failed",
931                            GCCause::to_string(gch->gc_cause()));
932      assert(gch->gc_cause() == GCCause::_scavenge_alot ||
933             (GCCause::is_user_requested_gc(gch->gc_cause()) && UseConcMarkSweepGC && ExplicitGCInvokesConcurrent) ||
934             !gch->incremental_collection_failed(),
935             "Twice in a row");
936      seen_incremental_collection_failed = false;
937    }
938#endif // ASSERT
939  }
940
941  if (ZapUnusedHeapArea) {
942    eden()->check_mangled_unused_area_complete();
943    from()->check_mangled_unused_area_complete();
944    to()->check_mangled_unused_area_complete();
945  }
946
947  if (!CleanChunkPoolAsync) {
948    Chunk::clean_chunk_pool();
949  }
950
951  // update the generation and space performance counters
952  update_counters();
953  gch->gen_policy()->counters()->update_counters();
954}
955
956void DefNewGeneration::record_spaces_top() {
957  assert(ZapUnusedHeapArea, "Not mangling unused space");
958  eden()->set_top_for_allocations();
959  to()->set_top_for_allocations();
960  from()->set_top_for_allocations();
961}
962
963void DefNewGeneration::ref_processor_init() {
964  Generation::ref_processor_init();
965}
966
967
968void DefNewGeneration::update_counters() {
969  if (UsePerfData) {
970    _eden_counters->update_all();
971    _from_counters->update_all();
972    _to_counters->update_all();
973    _gen_counters->update_all();
974  }
975}
976
977void DefNewGeneration::verify() {
978  eden()->verify();
979  from()->verify();
980    to()->verify();
981}
982
983void DefNewGeneration::print_on(outputStream* st) const {
984  Generation::print_on(st);
985  st->print("  eden");
986  eden()->print_on(st);
987  st->print("  from");
988  from()->print_on(st);
989  st->print("  to  ");
990  to()->print_on(st);
991}
992
993
994const char* DefNewGeneration::name() const {
995  return "def new generation";
996}
997
998// Moved from inline file as they are not called inline
999CompactibleSpace* DefNewGeneration::first_compaction_space() const {
1000  return eden();
1001}
1002
1003HeapWord* DefNewGeneration::allocate(size_t word_size, bool is_tlab) {
1004  // This is the slow-path allocation for the DefNewGeneration.
1005  // Most allocations are fast-path in compiled code.
1006  // We try to allocate from the eden.  If that works, we are happy.
1007  // Note that since DefNewGeneration supports lock-free allocation, we
1008  // have to use it here, as well.
1009  HeapWord* result = eden()->par_allocate(word_size);
1010  if (result != NULL) {
1011    if (CMSEdenChunksRecordAlways && _old_gen != NULL) {
1012      _old_gen->sample_eden_chunk();
1013    }
1014  } else {
1015    // If the eden is full and the last collection bailed out, we are running
1016    // out of heap space, and we try to allocate the from-space, too.
1017    // allocate_from_space can't be inlined because that would introduce a
1018    // circular dependency at compile time.
1019    result = allocate_from_space(word_size);
1020  }
1021  return result;
1022}
1023
1024HeapWord* DefNewGeneration::par_allocate(size_t word_size,
1025                                         bool is_tlab) {
1026  HeapWord* res = eden()->par_allocate(word_size);
1027  if (CMSEdenChunksRecordAlways && _old_gen != NULL) {
1028    _old_gen->sample_eden_chunk();
1029  }
1030  return res;
1031}
1032
1033size_t DefNewGeneration::tlab_capacity() const {
1034  return eden()->capacity();
1035}
1036
1037size_t DefNewGeneration::tlab_used() const {
1038  return eden()->used();
1039}
1040
1041size_t DefNewGeneration::unsafe_max_tlab_alloc() const {
1042  return unsafe_max_alloc_nogc();
1043}
1044