jdk8-mips64-public/hotspot: src/share/vm/memory/sharedHeap.cpp@8c95980d0b66

     1 /*

     2  * Copyright (c) 2000, 2014, 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  */

    25 #include "precompiled.hpp"

    26 #include "classfile/symbolTable.hpp"

    27 #include "classfile/systemDictionary.hpp"

    28 #include "code/codeCache.hpp"

    29 #include "gc_interface/collectedHeap.inline.hpp"

    30 #include "memory/sharedHeap.hpp"

    31 #include "oops/oop.inline.hpp"

    32 #include "runtime/atomic.inline.hpp"

    33 #include "runtime/fprofiler.hpp"

    34 #include "runtime/java.hpp"

    35 #include "utilities/copy.hpp"

    36 #include "utilities/workgroup.hpp"

    38 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

    40 SharedHeap* SharedHeap::_sh;

    42 SharedHeap::SharedHeap(CollectorPolicy* policy_) :

    43   CollectedHeap(),

    44   _collector_policy(policy_),

    45   _rem_set(NULL),

    46   _strong_roots_parity(0),

    47   _workers(NULL)

    48 {

    49   _sh = this;  // ch is static, should be set only once.

    50   if ((UseParNewGC ||

    51       (UseConcMarkSweepGC && (CMSParallelInitialMarkEnabled ||

    52                               CMSParallelRemarkEnabled)) ||

    53        UseG1GC) &&

    54       ParallelGCThreads > 0) {

    55     _workers = new FlexibleWorkGang("Parallel GC Threads", ParallelGCThreads,

    56                             /* are_GC_task_threads */true,

    57                             /* are_ConcurrentGC_threads */false);

    58     if (_workers == NULL) {

    59       vm_exit_during_initialization("Failed necessary allocation.");

    60     } else {

    61       _workers->initialize_workers();

    62     }

    63   }

    64 }

    66 bool SharedHeap::heap_lock_held_for_gc() {

    67   Thread* t = Thread::current();

    68   return    Heap_lock->owned_by_self()

    69          || (   (t->is_GC_task_thread() ||  t->is_VM_thread())

    70              && _thread_holds_heap_lock_for_gc);

    71 }

    73 void SharedHeap::set_par_threads(uint t) {

    74   assert(t == 0 || !UseSerialGC, "Cannot have parallel threads");

    75   _n_par_threads = t;

    76 }

    78 void SharedHeap::change_strong_roots_parity() {

    79   // Also set the new collection parity.

    80   assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,

    81          "Not in range.");

    82   _strong_roots_parity++;

    83   if (_strong_roots_parity == 3) _strong_roots_parity = 1;

    84   assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,

    85          "Not in range.");

    86 }

    88 SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* heap, bool activate)

    89   : MarkScope(activate), _sh(heap)

    90 {

    91   if (_active) {

    92     _sh->change_strong_roots_parity();

    93     // Zero the claimed high water mark in the StringTable

    94     StringTable::clear_parallel_claimed_index();

    95   }

    96 }

    98 void SharedHeap::set_barrier_set(BarrierSet* bs) {

    99   _barrier_set = bs;

   100   // Cached barrier set for fast access in oops

   101   oopDesc::set_bs(bs);

   102 }

   104 void SharedHeap::post_initialize() {

   105   CollectedHeap::post_initialize();

   106   ref_processing_init();

   107 }

   109 void SharedHeap::ref_processing_init() {}

   111 // Some utilities.

   112 void SharedHeap::print_size_transition(outputStream* out,

   113                                        size_t bytes_before,

   114                                        size_t bytes_after,

   115                                        size_t capacity) {

   116   out->print(" %d%s->%d%s(%d%s)",

   117              byte_size_in_proper_unit(bytes_before),

   118              proper_unit_for_byte_size(bytes_before),

   119              byte_size_in_proper_unit(bytes_after),

   120              proper_unit_for_byte_size(bytes_after),

   121              byte_size_in_proper_unit(capacity),

   122              proper_unit_for_byte_size(capacity));

   123 }

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