Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 #include "precompiled.hpp"

 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"

 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"

 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"

 #include "gc_implementation/parallelScavenge/psPermGen.hpp"

 #include "gc_implementation/shared/gcUtil.hpp"

 #include "gc_implementation/shared/markSweep.inline.hpp"

 #include "oops/markOop.inline.hpp"

 PSPermGen::PSPermGen(ReservedSpace rs, size_t alignment,

                      size_t initial_size, size_t min_size, size_t max_size,

                      const char* gen_name, int level) :

   PSOldGen(rs, alignment, initial_size, min_size, max_size, gen_name, level),

   _last_used(0)

 {

   assert(object_mark_sweep() != NULL, "Sanity");

   object_mark_sweep()->set_allowed_dead_ratio(PermMarkSweepDeadRatio);

   _avg_size = new AdaptivePaddedAverage(AdaptivePermSizeWeight,

                                         PermGenPadding);

 }

 HeapWord* PSPermGen::allocate_permanent(size_t size) {

   assert_locked_or_safepoint(Heap_lock);

   HeapWord* obj = allocate_noexpand(size);

   if (obj == NULL) {

     obj = expand_and_allocate(size);

   }

   return obj;

 }

 void PSPermGen::compute_new_size(size_t used_before_collection) {

   // Update our padded average of objects allocated in perm

   // gen between collections.

   assert(used_before_collection >= _last_used,

                                 "negative allocation amount since last GC?");

   const size_t alloc_since_last_gc = used_before_collection - _last_used;

   _avg_size->sample(alloc_since_last_gc);

   const size_t current_live = used_in_bytes();

   // Stash away the current amount live for the next call to this method.

   _last_used = current_live;

   // We have different alignment constraints than the rest of the heap.

   const size_t alignment = MAX2(MinPermHeapExpansion,

                                 virtual_space()->alignment());

   // Compute the desired size:

   //  The free space is the newly computed padded average,

   //  so the desired size is what's live + the free space.

   size_t desired_size = current_live + (size_t)_avg_size->padded_average();

   desired_size = align_size_up(desired_size, alignment);

   // ...and no larger or smaller than our max and min allowed.

   desired_size = MAX2(MIN2(desired_size, _max_gen_size), _min_gen_size);

   assert(desired_size <= _max_gen_size, "just checking");

   const size_t size_before = _virtual_space->committed_size();

   if (desired_size == size_before) {

     // no change, we're done

     return;

   }

   {

     // We'll be growing or shrinking the heap:  in either case,

     // we need to hold a lock.

     MutexLocker x(ExpandHeap_lock);

     if (desired_size > size_before) {

       const size_t change_bytes = desired_size - size_before;

       const size_t aligned_change_bytes =

         align_size_up(change_bytes, alignment);

       expand_by(aligned_change_bytes);

     } else {

       // Shrinking

       const size_t change_bytes =

         size_before - desired_size;

       const size_t aligned_change_bytes = align_size_down(change_bytes, alignment);

       shrink(aligned_change_bytes);

     }

   }

   // While this code isn't controlled by AdaptiveSizePolicy, it's

   // convenient to see all resizing decsions under the same flag.

   if (PrintAdaptiveSizePolicy) {

     ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();

     assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");

     gclog_or_tty->print_cr("AdaptiveSizePolicy::perm generation size: "

                            "collection: %d "

                            "(" SIZE_FORMAT ") -> (" SIZE_FORMAT ") ",

                            heap->total_collections(),

                            size_before, _virtual_space->committed_size());

   }

 }

 void PSPermGen::precompact() {

   // Reset start array first.

   _start_array.reset();

   object_mark_sweep()->precompact();

 }